WebCore/khtml/rendering/render_text.cpp

   1 /**
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * (C) 1999 Lars Knoll (knoll@kde.org)
   5  * (C) 2000 Dirk Mueller (mueller@kde.org)
   6  * Copyright (C) 2004 Apple Computer, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  *
  23  */
  24 //#define DEBUG_LAYOUT
  25 //#define BIDI_DEBUG
  26
  27 #include "rendering/render_text.h"
  28
  29 #include "rendering/render_canvas.h"
  30 #include "rendering/render_object.h"
  31 #include "rendering/break_lines.h"
  32 #include "xml/dom2_rangeimpl.h"
  33 #include "xml/dom_nodeimpl.h"
  34 #include "xml/dom_docimpl.h"
  35 #include "xml/dom_position.h"
  36 #include "render_arena.h"
  37
  38 #include "misc/loader.h"
  39
  40 #include "khtml_part.h"
  41
  42 #include <qpainter.h>
  43 #include <kdebug.h>
  44 #include <assert.h>
  45
  46 #include <unicode/ubrk.h>
  47 #include <unicode/uloc.h>
  48 #include <unicode/utypes.h>
  49 #include <unicode/parseerr.h>
  50
  51 using namespace khtml;
  52 using namespace DOM;
  53
  54 #ifndef NDEBUG
  55 static bool inInlineTextBoxDetach;
  56 #endif
  57
  58 void InlineTextBox::detach(RenderArena* renderArena)
  59 {
  60 #ifndef NDEBUG
  61     inInlineTextBoxDetach = true;
  62 #endif
  63     delete this;
  64 #ifndef NDEBUG
  65     inInlineTextBoxDetach = false;
  66 #endif
  67
  68     // Recover the size left there for us by operator delete and free the memory.
  69     renderArena->free(*(size_t *)this, this);
  70 }
  71
  72 void* InlineTextBox::operator new(size_t sz, RenderArena* renderArena) throw()
  73 {
  74     return renderArena->allocate(sz);
  75 }
  76
  77 void InlineTextBox::operator delete(void* ptr, size_t sz)
  78 {
  79     assert(inInlineTextBoxDetach);
  80
  81     // Stash size where detach can find it.
  82     *(size_t *)ptr = sz;
  83 }
  84
  85 RenderText* InlineTextBox::textObject()
  86 {
  87     return static_cast<RenderText*>(m_object);
  88 }
  89
  90 bool InlineTextBox::checkVerticalPoint(int _y, int _ty, int _h)
  91 {
  92     int topY = m_y;
  93     int bottomY = m_y + m_height;
  94     if (root()->hasSelectedChildren()) {
  95         topY = kMin(root()->selectionTop(), topY);
  96         bottomY = kMax(bottomY, root()->bottomOverflow());
  97     }
  98     if ((_ty + topY >= _y + _h) || (_ty + bottomY <= _y))
  99         return false;
 100     return true;
 101 }
 102
 103 bool InlineTextBox::isSelected(int startPos, int endPos) const
 104 {
 105     int sPos = kMax(startPos - m_start, 0);
 106     int ePos = kMin(endPos - m_start, (int)m_len);
 107     return (sPos < ePos);
 108 }
 109
 110 RenderObject::SelectionState InlineTextBox::selectionState()
 111 {
 112     RenderObject::SelectionState state = object()->selectionState();
 113     if (state == RenderObject::SelectionStart || state == RenderObject::SelectionEnd ||
 114         state == RenderObject::SelectionBoth) {
 115         int startPos, endPos;
 116         object()->selectionStartEnd(startPos, endPos);
 117
 118         bool start = (state != RenderObject::SelectionEnd && startPos >= m_start && startPos < m_start + m_len);
 119         bool end = (state != RenderObject::SelectionStart && endPos > m_start && endPos <= m_start + m_len);
 120         if (start && end)
 121             state = RenderObject::SelectionBoth;
 122         else if (start)
 123             state = RenderObject::SelectionStart;
 124         else if (end)
 125             state = RenderObject::SelectionEnd;
 126         else if ((state == RenderObject::SelectionEnd || startPos < m_start) &&
 127                  (state == RenderObject::SelectionStart || endPos > m_start + m_len))
 128             state = RenderObject::SelectionInside;
 129     }
 130     return state;
 131 }
 132
 133 QRect InlineTextBox::selectionRect(int tx, int ty, int startPos, int endPos)
 134 {
 135     int sPos = kMax(startPos - m_start, 0);
 136     int ePos = kMin(endPos - m_start, (int)m_len);
 137
 138     if (sPos >= ePos)
 139         return QRect();
 140
 141     RootInlineBox* rootBox = root();
 142     int selStart = m_reversed ? m_x + m_width : m_x;
 143     int selEnd = selStart;
 144     int selTop = rootBox->selectionTop();
 145     int selHeight = rootBox->selectionHeight();
 146
 147     // FIXME: For justified text, just return the entire text box's rect.  At the moment there's still no easy
 148     // way to get the width of a run including the justification padding.
 149     if (sPos > 0 && !m_toAdd) {
 150         // The selection begins in the middle of our run.
 151         int w = textObject()->width(m_start, sPos, m_firstLine);
 152         if (m_reversed)
 153             selStart -= w;
 154         else
 155             selStart += w;
 156     }
 157
 158     if (m_toAdd || (sPos == 0 && ePos == m_len)) {
 159         if (m_reversed)
 160             selEnd = m_x;
 161         else
 162             selEnd = m_x + m_width;
 163     }
 164     else {
 165         // Our run is partially selected, and so we have to actually do a measurement.
 166         int w = textObject()->width(sPos + m_start, ePos - sPos, m_firstLine);
 167         if (m_reversed)
 168             selEnd = selStart - w;
 169         else
 170             selEnd = selStart + w;
 171     }
 172
 173     int selLeft = m_reversed ? selEnd : selStart;
 174     int selRight = m_reversed ? selStart : selEnd;
 175
 176     return QRect(selLeft + tx, selTop + ty, selRight - selLeft, selHeight);
 177 }
 178
 179 void InlineTextBox::deleteLine(RenderArena* arena)
 180 {
 181     static_cast<RenderText*>(m_object)->removeTextBox(this);
 182     detach(arena);
 183 }
 184
 185 void InlineTextBox::extractLine()
 186 {
 187     if (m_extracted)
 188         return;
 189
 190     static_cast<RenderText*>(m_object)->extractTextBox(this);
 191 }
 192
 193 void InlineTextBox::attachLine()
 194 {
 195     if (!m_extracted)
 196         return;
 197
 198     static_cast<RenderText*>(m_object)->attachTextBox(this);
 199 }
 200
 201 int InlineTextBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox)
 202 {
 203     if (foundBox) {
 204         m_truncation = cFullTruncation;
 205         return -1;
 206     }
 207
 208     int ellipsisX = ltr ? blockEdge - ellipsisWidth : blockEdge + ellipsisWidth;
 209
 210     // For LTR, if the left edge of the ellipsis is to the left of our text run, then we are the run that will get truncated.
 211     if (ltr) {
 212         if (ellipsisX <= m_x) {
 213             // Too far.  Just set full truncation, but return -1 and let the ellipsis just be placed at the edge of the box.
 214             m_truncation = cFullTruncation;
 215             foundBox = true;
 216             return -1;
 217         }
 218
 219         if (ellipsisX < m_x + m_width) {
 220             if (m_reversed)
 221                 return -1; // FIXME: Support LTR truncation when the last run is RTL someday.
 222
 223             foundBox = true;
 224
 225             int offset = offsetForPosition(ellipsisX, false);
 226             if (offset == 0) {
 227                 // No characters should be rendered.  Set ourselves to full truncation and place the ellipsis at the min of our start
 228                 // and the ellipsis edge.
 229                 m_truncation = cFullTruncation;
 230                 return kMin(ellipsisX, m_x);
 231             }
 232
 233             // Set the truncation index on the text run.  The ellipsis needs to be placed just after the last visible character.
 234             m_truncation = offset + m_start;
 235             return m_x + static_cast<RenderText*>(m_object)->width(m_start, offset, m_firstLine);
 236         }
 237     }
 238     else {
 239         // FIXME: Support RTL truncation someday, including both modes (when the leftmost run on the line is either RTL or LTR)
 240     }
 241     return -1;
 242 }
 243
 244 static int
 245 simpleDifferenceBetweenColors(QColor c1, QColor c2)
 246 {
 247     // a distance could be computed by squaring the differences between components, but
 248     // this is faster and so far seems good enough for our purposes.
 249     return abs(c1.red() - c2.red()) + abs(c1.green() - c2.green()) + abs(c1.blue() - c2.blue());
 250 }
 251
 252 static QColor
 253 correctedTextColor(QColor textColor, QColor backgroundColor)
 254 {
 255     // Adjust the text color if it is too close to the background color,
 256     // by darkening or lightening it to move it further away.
 257
 258     int d = simpleDifferenceBetweenColors(textColor, backgroundColor);
 259     // semi-arbitrarily chose 255 value here after a few tests;
 260     if (d > 255) {
 261         return textColor;
 262     }
 263
 264     int distanceFromWhite = simpleDifferenceBetweenColors(textColor, Qt::white);
 265     int distanceFromBlack = simpleDifferenceBetweenColors(textColor, Qt::black);
 266
 267     if (distanceFromWhite < distanceFromBlack) {
 268         return textColor.dark();
 269     }
 270
 271     return textColor.light();
 272 }
 273
 274 bool InlineTextBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty)
 275 {
 276     if (object()->isBR())
 277         return false;
 278
 279     QRect rect(tx + m_x, ty + m_y, m_width, m_height);
 280     if (m_truncation != cFullTruncation &&
 281         object()->style()->visibility() == VISIBLE && rect.contains(x, y)) {
 282         object()->setInnerNode(i);
 283         return true;
 284     }
 285     return false;
 286 }
 287
 288 void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
 289 {
 290     if (object()->isBR() || !object()->shouldPaintWithinRoot(i) || object()->style()->visibility() != VISIBLE ||
 291         m_truncation == cFullTruncation || i.phase == PaintActionOutline)
 292         return;
 293
 294     int xPos = tx + m_x;
 295     int w = width();
 296     if ((xPos >= i.r.x() + i.r.width()) || (xPos + w <= i.r.x()))
 297         return;
 298
 299     bool isPrinting = (i.p->device()->devType() == QInternal::Printer);
 300
 301     // Determine whether or not we're selected.
 302     bool haveSelection = !isPrinting && selectionState() != RenderObject::SelectionNone;
 303     if (!haveSelection && i.phase == PaintActionSelection)
 304         // When only painting the selection, don't bother to paint if there is none.
 305         return;
 306
 307     // Determine whether or not we have marked text.
 308     RangeImpl *markedTextRange = KWQ(object()->document()->part())->markedTextRange();
 309     int exception = 0;
 310     bool haveMarkedText = markedTextRange && markedTextRange->startContainer(exception) == object()->node();
 311     bool markedTextUsesUnderlines = KWQ(object()->document()->part())->markedTextUsesUnderlines();
 312
 313     // Set our font.
 314     RenderStyle* styleToUse = object()->style(m_firstLine);
 315     int d = styleToUse->textDecorationsInEffect();
 316     if (styleToUse->font() != i.p->font())
 317         i.p->setFont(styleToUse->font());
 318     const Font *font = &styleToUse->htmlFont();
 319
 320     // 1. Paint backgrounds behind text if needed.  Examples of such backgrounds include selection
 321     // and marked text.
 322     if ((haveSelection || haveMarkedText) && !markedTextUsesUnderlines && i.phase != PaintActionSelection && !isPrinting) {
 323         if (haveMarkedText)
 324             paintMarkedTextBackground(i.p, tx, ty, styleToUse, font, markedTextRange->startOffset(exception), markedTextRange->endOffset(exception));
 325
 326         if (haveSelection)
 327             paintSelection(i.p, tx, ty, styleToUse, font);
 328     }
 329
 330     // 2. Now paint the foreground, including text and decorations like underline/overline (in quirks mode only).
 331     if (m_len <= 0) return;
 332     QValueList<DocumentMarker> markers = object()->document()->markersForNode(object()->node());
 333     QValueListIterator <DocumentMarker> markerIt = markers.begin();
 334
 335     QValueList<KWQKHTMLPart::MarkedTextUnderline> underlines;
 336     if (haveMarkedText && markedTextUsesUnderlines) {
 337         underlines = KWQ(object()->document()->part())->markedTextUnderlines();
 338     }
 339     QValueListIterator<KWQKHTMLPart::MarkedTextUnderline> underlineIt = underlines.begin();
 340
 341     QColor textColor = styleToUse->color();
 342
 343     // Make the text color legible against a white background
 344     if (styleToUse->forceBackgroundsToWhite())
 345         textColor = correctedTextColor(textColor, Qt::white);
 346
 347     if (textColor != i.p->pen().color())
 348         i.p->setPen(textColor);
 349
 350     // Set a text shadow if we have one.
 351     // FIXME: Support multiple shadow effects.  Need more from the CG API before
 352     // we can do this.
 353     bool setShadow = false;
 354     if (styleToUse->textShadow()) {
 355         i.p->setShadow(styleToUse->textShadow()->x, styleToUse->textShadow()->y,
 356                         styleToUse->textShadow()->blur, styleToUse->textShadow()->color);
 357         setShadow = true;
 358     }
 359
 360     bool paintSelectedTextOnly = (i.phase == PaintActionSelection);
 361     bool paintSelectedTextSeparately = false; // Whether or not we have to do multiple paints.  Only
 362                                               // necessary when a custom ::selection foreground color is applied.
 363     QColor selectionColor = i.p->pen().color();
 364     ShadowData* selectionTextShadow = 0;
 365     if (haveSelection) {
 366         RenderStyle* pseudoStyle = object()->getPseudoStyle(RenderStyle::SELECTION);
 367         if (pseudoStyle) {
 368             if (pseudoStyle->color() != selectionColor || pseudoStyle->textShadow()) {
 369                 if (!paintSelectedTextOnly)
 370                     paintSelectedTextSeparately = true;
 371                 if (pseudoStyle->color() != selectionColor)
 372                     selectionColor = pseudoStyle->color();
 373                 if (pseudoStyle->textShadow())
 374                     selectionTextShadow = pseudoStyle->textShadow();
 375             }
 376         }
 377     }
 378
 379     if (!paintSelectedTextOnly && !paintSelectedTextSeparately) {
 380         // paint all the text
 381         // FIXME: Handle RTL direction, handle reversed strings.  For now truncation can only be turned on
 382         // for non-reversed LTR strings.
 383         int endPoint = m_len;
 384         if (m_truncation != cNoTruncation)
 385             endPoint = m_truncation - m_start;
 386         font->drawText(i.p, m_x + tx, m_y + ty + m_baseline,
 387                        textObject()->string()->s, textObject()->string()->l, m_start, endPoint,
 388                        m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, styleToUse->visuallyOrdered());
 389     } else {
 390         int sPos, ePos;
 391         selectionStartEnd(sPos, ePos);
 392         if (paintSelectedTextSeparately) {
 393             // paint only the text that is not selected
 394             if (sPos >= ePos) {
 395                 font->drawText(i.p, m_x + tx, m_y + ty + m_baseline,
 396                                textObject()->string()->s, textObject()->string()->l, m_start, m_len,
 397                                m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, styleToUse->visuallyOrdered());
 398             } else {
 399                 if (sPos - 1 >= 0) {
 400                     font->drawText(i.p, m_x + tx, m_y + ty + m_baseline, textObject()->string()->s,
 401                                    textObject()->string()->l, m_start, m_len,
 402                                    m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, styleToUse->visuallyOrdered(), 0, sPos);
 403                 }
 404                 if (ePos < m_start + m_len) {
 405                     font->drawText(i.p, m_x + tx, m_y + ty + m_baseline, textObject()->string()->s,
 406                                    textObject()->string()->l, m_start, m_len,
 407                                    m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, styleToUse->visuallyOrdered(), ePos, -1);
 408                 }
 409             }
 410         }
 411
 412         if (sPos < ePos) {
 413             // paint only the text that is selected
 414             if (selectionColor != i.p->pen().color())
 415                 i.p->setPen(selectionColor);
 416
 417             if (selectionTextShadow)
 418                 i.p->setShadow(selectionTextShadow->x,
 419                                selectionTextShadow->y,
 420                                selectionTextShadow->blur,
 421                                selectionTextShadow->color);
 422             font->drawText(i.p, m_x + tx, m_y + ty + m_baseline, textObject()->string()->s,
 423                            textObject()->string()->l, m_start, m_len,
 424                            m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, styleToUse->visuallyOrdered(), sPos, ePos);
 425             if (selectionTextShadow)
 426                 i.p->clearShadow();
 427         }
 428     }
 429
 430     // Paint decorations
 431     if (d != TDNONE && i.phase != PaintActionSelection && styleToUse->htmlHacks()) {
 432         i.p->setPen(styleToUse->color());
 433         paintDecoration(i.p, tx, ty, d);
 434     }
 435
 436     // Draw any doc markers that touch this run
 437     // Note end() points at the last char, not one past it like endOffset and ranges do
 438     if (i.phase != PaintActionSelection) {
 439         for ( ; markerIt != markers.end(); markerIt++) {
 440             DocumentMarker marker = *markerIt;
 441
 442             if (marker.endOffset <= start())
 443                 // marker is completely before this run.  This might be a marker that sits before the
 444                 // first run we draw, or markers that were within runs we skipped due to truncation.
 445                 continue;
 446
 447             if (marker.startOffset <= end()) {
 448                 // marker intersects this run.  Paint it.
 449                 paintMarker(i.p, tx, ty, marker);
 450                 if (marker.endOffset > end() + 1)
 451                     // marker also runs into the next run. Bail now, no more marker advancement.
 452                     break;
 453             } else
 454                 // marker is completely after this run, bail.  A later run will paint it.
 455                 break;
 456         }
 457
 458
 459         for ( ; underlineIt != underlines.end(); underlineIt++) {
 460             KWQKHTMLPart::MarkedTextUnderline underline = *underlineIt;
 461
 462             if (underline.endOffset <= start())
 463                 // underline is completely before this run.  This might be an underlinethat sits
 464                 // before the first run we draw, or underlines that were within runs we skipped
 465                 // due to truncation.
 466                 continue;
 467
 468             if (underline.startOffset <= end()) {
 469                 // underline intersects this run.  Paint it.
 470                 paintMarkedTextUnderline(i.p, tx, ty, underline);
 471                 if (underline.endOffset > end() + 1)
 472                     // underline also runs into the next run. Bail now, no more marker advancement.
 473                     break;
 474             } else
 475                 // underline is completely after this run, bail.  A later run will paint it.
 476                 break;
 477         }
 478
 479
 480
 481     }
 482
 483     if (setShadow)
 484         i.p->clearShadow();
 485 }
 486
 487 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos)
 488 {
 489     int startPos, endPos;
 490     if (object()->selectionState() == RenderObject::SelectionInside) {
 491         startPos = 0;
 492         endPos = textObject()->string()->l;
 493     } else {
 494         textObject()->selectionStartEnd(startPos, endPos);
 495         if (object()->selectionState() == RenderObject::SelectionStart)
 496             endPos = textObject()->string()->l;
 497         else if (object()->selectionState() == RenderObject::SelectionEnd)
 498             startPos = 0;
 499     }
 500
 501     sPos = kMax(startPos - m_start, 0);
 502     ePos = kMin(endPos - m_start, (int)m_len);
 503 }
 504
 505 void InlineTextBox::paintSelection(QPainter* p, int tx, int ty, RenderStyle* style, const Font* f)
 506 {
 507     // See if we have a selection to paint at all.
 508     int sPos, ePos;
 509     selectionStartEnd(sPos, ePos);
 510     if (sPos >= ePos)
 511         return;
 512
 513     // Macintosh-style text highlighting is to draw with a particular background color, not invert.
 514     QColor textColor = style->color();
 515     QColor c = object()->selectionColor(p);
 516     if (!c.isValid())
 517         return;
 518
 519     // If the text color ends up being the same as the selection background, invert the selection
 520     // background.  This should basically never happen, since the selection has transparency.
 521     if (textColor == c)
 522         c = QColor(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
 523
 524     p->save();
 525     p->setPen(c); // Don't draw text at all!
 526     RootInlineBox* r = root();
 527     int x = m_x + tx;
 528     int y = r->selectionTop();
 529     int h = r->selectionHeight();
 530     f->drawHighlightForText(p, x, y + ty, h,
 531                             textObject()->str->s, textObject()->str->l, m_start, m_len,
 532                             m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, style->visuallyOrdered(), sPos, ePos, c);
 533     p->restore();
 534 }
 535
 536 void InlineTextBox::paintMarkedTextBackground(QPainter* p, int tx, int ty, RenderStyle* style, const Font* f, int startPos, int endPos)
 537 {
 538     int offset = m_start;
 539     int sPos = kMax(startPos - offset, 0);
 540     int ePos = kMin(endPos - offset, (int)m_len);
 541
 542     if (sPos >= ePos)
 543         return;
 544
 545     p->save();
 546
 547     QColor c = QColor(225, 221, 85);
 548
 549     p->setPen(c); // Don't draw text at all!
 550
 551     RootInlineBox* r = root();
 552     int x = m_x + tx;
 553     int y = r->selectionTop();
 554     int h = r->selectionHeight();
 555     f->drawHighlightForText(p, x, y + ty, h, textObject()->str->s, textObject()->str->l, m_start, m_len,
 556             m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, style->visuallyOrdered(), sPos, ePos, c);
 557     p->restore();
 558 }
 559
 560 void InlineTextBox::paintDecoration( QPainter *pt, int _tx, int _ty, int deco)
 561 {
 562     _tx += m_x;
 563     _ty += m_y;
 564
 565     if (m_truncation == cFullTruncation)
 566         return;
 567
 568     int width = (m_truncation == cNoTruncation) ?
 569                 m_width : static_cast<RenderText*>(m_object)->width(m_start, m_truncation - m_start, m_firstLine);
 570
 571     // Get the text decoration colors.
 572     QColor underline, overline, linethrough;
 573     object()->getTextDecorationColors(deco, underline, overline, linethrough, true);
 574
 575     // Use a special function for underlines to get the positioning exactly right.
 576     if (deco & UNDERLINE) {
 577         pt->setPen(underline);
 578         pt->drawLineForText(_tx, _ty, m_baseline, width);
 579     }
 580     if (deco & OVERLINE) {
 581         pt->setPen(overline);
 582         pt->drawLineForText(_tx, _ty, 0, width);
 583     }
 584     if (deco & LINE_THROUGH) {
 585         pt->setPen(linethrough);
 586         pt->drawLineForText(_tx, _ty, 2*m_baseline/3, width);
 587     }
 588 }
 589
 590 void InlineTextBox::paintMarker(QPainter *pt, int _tx, int _ty, DocumentMarker marker)
 591 {
 592     _tx += m_x;
 593     _ty += m_y;
 594
 595     if (m_truncation == cFullTruncation)
 596         return;
 597
 598     int start = 0;                  // start of line to draw, relative to _tx
 599     int width = m_width;            // how much line to draw
 600     bool useWholeWidth = true;
 601     ulong paintStart = m_start;
 602     ulong paintEnd = end()+1;      // end points at the last char, not past it
 603     if (paintStart <= marker.startOffset) {
 604         paintStart = marker.startOffset;
 605         useWholeWidth = false;
 606         start = static_cast<RenderText*>(m_object)->width(m_start, paintStart - m_start, m_firstLine);
 607     }
 608     if (paintEnd != marker.endOffset) {      // end points at the last char, not past it
 609         paintEnd = kMin(paintEnd, marker.endOffset);
 610         useWholeWidth = false;
 611     }
 612     if (m_truncation != cNoTruncation) {
 613         paintEnd = kMin(paintEnd, (ulong)m_truncation);
 614         useWholeWidth = false;
 615     }
 616     if (!useWholeWidth) {
 617         width = static_cast<RenderText*>(m_object)->width(paintStart, paintEnd - paintStart, m_firstLine);
 618     }
 619
 620     // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
 621     // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
 622     // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
 623     // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
 624     // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
 625     // we pin to two pixels under the baseline.
 626     int lineThickness = pt->misspellingLineThickness();
 627     int descent = m_height - m_baseline;
 628     int underlineOffset;
 629     if (descent <= (2 + lineThickness)) {
 630         // place the underline at the very bottom of the text in small/medium fonts
 631         underlineOffset = m_height - lineThickness;
 632     } else {
 633         // in larger fonts, tho, place the underline up near the baseline to prevent big gap
 634         underlineOffset = m_baseline + 2;
 635     }
 636     pt->drawLineForMisspelling(_tx + start, _ty + underlineOffset, width);
 637 }
 638
 639 void InlineTextBox::paintMarkedTextUnderline(QPainter *pt, int _tx, int _ty, KWQKHTMLPart::MarkedTextUnderline underline)
 640 {
 641     _tx += m_x;
 642     _ty += m_y;
 643
 644     if (m_truncation == cFullTruncation)
 645         return;
 646
 647     int start = 0;                  // start of line to draw, relative to _tx
 648     int width = m_width;            // how much line to draw
 649     bool useWholeWidth = true;
 650     ulong paintStart = m_start;
 651     ulong paintEnd = end()+1;      // end points at the last char, not past it
 652     if (paintStart <= underline.startOffset) {
 653         paintStart = underline.startOffset;
 654         useWholeWidth = false;
 655         start = static_cast<RenderText*>(m_object)->width(m_start, paintStart - m_start, m_firstLine);
 656     }
 657     if (paintEnd != underline.endOffset) {      // end points at the last char, not past it
 658         paintEnd = kMin(paintEnd, (ulong)underline.endOffset);
 659         useWholeWidth = false;
 660     }
 661     if (m_truncation != cNoTruncation) {
 662         paintEnd = kMin(paintEnd, (ulong)m_truncation);
 663         useWholeWidth = false;
 664     }
 665     if (!useWholeWidth) {
 666         width = static_cast<RenderText*>(m_object)->width(paintStart, paintEnd - paintStart, m_firstLine);
 667     }
 668
 669     int underlineOffset = m_height - 3;
 670     pt->setPen(QPen(underline.color, underline.thick ? 2 : 0));
 671     pt->drawLineForText(_tx + start, _ty, underlineOffset, width);
 672 }
 673
 674 long InlineTextBox::caretMinOffset() const
 675 {
 676     return m_start;
 677 }
 678
 679 long InlineTextBox::caretMaxOffset() const
 680 {
 681     return m_start + m_len;
 682 }
 683
 684 unsigned long InlineTextBox::caretMaxRenderedOffset() const
 685 {
 686     return m_start + m_len;
 687 }
 688
 689 static UBreakIterator *getCharacterBreakIterator(const DOMStringImpl *i)
 690 {
 691     // The locale is currently ignored when determining character cluster breaks.  This may change
 692     // in the future (according to Deborah Goldsmith).
 693     static bool createdIterator = false;
 694     static UBreakIterator *iterator;
 695     UErrorCode status;
 696     if (!createdIterator) {
 697         status = U_ZERO_ERROR;
 698         iterator = ubrk_open(UBRK_CHARACTER, "en_us", NULL, 0, &status);
 699         createdIterator = true;
 700     }
 701     if (!iterator) {
 702         return NULL;
 703     }
 704     status = U_ZERO_ERROR;
 705     ubrk_setText(iterator, reinterpret_cast<const UChar *>(i->s), i->l, &status);
 706     if (status != U_ZERO_ERROR) {
 707         return NULL;
 708     }
 709     return iterator;
 710 }
 711
 712 long RenderText::previousOffset (long current) const
 713 {
 714     UBreakIterator *iterator = getCharacterBreakIterator(str);
 715     if (iterator) {
 716         return ubrk_preceding(iterator, current);
 717     }
 718     return current - 1;
 719 }
 720
 721 long RenderText::nextOffset (long current) const
 722 {
 723     UBreakIterator *iterator = getCharacterBreakIterator(str);
 724     if (iterator) {
 725         return ubrk_following(iterator, current);
 726     }
 727     return current + 1;
 728 }
 729
 730 int InlineTextBox::offsetForPosition(int _x, bool includePartialGlyphs) const
 731 {
 732     RenderText* text = static_cast<RenderText*>(m_object);
 733     const Font* f = text->htmlFont(m_firstLine);
 734     return f->checkSelectionPoint(text->str->s, text->str->l, m_start, m_len, m_toAdd, _x - m_x, m_reversed, includePartialGlyphs);
 735 }
 736
 737 int InlineTextBox::positionForOffset(int offset) const
 738 {
 739     RenderText *text = static_cast<RenderText *>(m_object);
 740     const QFontMetrics &fm = text->metrics(m_firstLine);
 741
 742     int left;
 743     if (m_reversed) {
 744         long len = m_start + m_len - offset;
 745         QString string(text->str->s + offset, len);
 746         left = m_x + fm.boundingRect(string, len).right();
 747     } else {
 748         long len = offset - m_start;
 749         QString string(text->str->s + m_start, len);
 750         left = m_x + fm.boundingRect(string, len).right();
 751     }
 752     // FIXME: Do we need to add rightBearing here?
 753     return left;
 754 }
 755
 756 // -------------------------------------------------------------------------------------
 757
 758 RenderText::RenderText(DOM::NodeImpl* node, DOMStringImpl *_str)
 759     : RenderObject(node), m_linesDirty(false)
 760 {
 761     // init RenderObject attributes
 762     setRenderText();   // our object inherits from RenderText
 763
 764     m_minWidth = -1;
 765     m_maxWidth = -1;
 766
 767 #ifdef APPLE_CHANGES
 768     m_monospaceCharacterWidth = 0;
 769     m_allAsciiChecked = false;
 770     m_allAscii = false;
 771 #endif
 772
 773     str = _str;
 774     if (str) {
 775         str = str->replace('\\', backslashAsCurrencySymbol());
 776         str->ref();
 777     }
 778     KHTMLAssert(!str || !str->l || str->s);
 779
 780     m_firstTextBox = m_lastTextBox = 0;
 781
 782     m_selectionState = SelectionNone;
 783
 784 #ifdef DEBUG_LAYOUT
 785     QConstString cstr(str->s, str->l);
 786     kdDebug( 6040 ) << "RenderText ctr( "<< cstr.string().length() << " )  '" << cstr.string() << "'" << endl;
 787 #endif
 788 }
 789
 790 void RenderText::setStyle(RenderStyle *_style)
 791 {
 792     if ( style() != _style ) {
 793         bool needToTransformText = (!style() && _style->textTransform() != TTNONE) ||
 794                                    (style() && style()->textTransform() != _style->textTransform());
 795
 796         RenderObject::setStyle( _style );
 797
 798         if (needToTransformText) {
 799             DOM::DOMStringImpl* textToTransform = originalString();
 800             if (textToTransform)
 801                 setText(textToTransform, true);
 802         }
 803 #if APPLE_CHANGES
 804         // setText also calls cacheWidths(), so there is no need to call it again in that case.
 805         else
 806             cacheWidths();
 807 #endif
 808     }
 809 }
 810
 811 RenderText::~RenderText()
 812 {
 813     if(str) str->deref();
 814 }
 815
 816 void RenderText::detach()
 817 {
 818     if (!documentBeingDestroyed()) {
 819         if (firstTextBox()) {
 820             if (isBR()) {
 821                 RootInlineBox* next = firstTextBox()->root()->nextRootBox();
 822                 if (next)
 823                     next->markDirty();
 824             }
 825             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
 826                 box->remove();
 827         }
 828         else if (parent())
 829             parent()->dirtyLinesFromChangedChild(this);
 830     }
 831     deleteTextBoxes();
 832     RenderObject::detach();
 833 }
 834
 835 void RenderText::extractTextBox(InlineTextBox* box)
 836 {
 837     m_lastTextBox = box->prevTextBox();
 838     if (box == m_firstTextBox)
 839         m_firstTextBox = 0;
 840     if (box->prevTextBox())
 841         box->prevTextBox()->setNextLineBox(0);
 842     box->setPreviousLineBox(0);
 843     for (InlineRunBox* curr = box; curr; curr = curr->nextLineBox())
 844         curr->setExtracted();
 845 }
 846
 847 void RenderText::attachTextBox(InlineTextBox* box)
 848 {
 849     if (m_lastTextBox) {
 850         m_lastTextBox->setNextLineBox(box);
 851         box->setPreviousLineBox(m_lastTextBox);
 852     }
 853     else
 854         m_firstTextBox = box;
 855     InlineTextBox* last = box;
 856     for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox()) {
 857         curr->setExtracted(false);
 858         last = curr;
 859     }
 860     m_lastTextBox = last;
 861 }
 862
 863 void RenderText::removeTextBox(InlineTextBox* box)
 864 {
 865     if (box == m_firstTextBox)
 866         m_firstTextBox = box->nextTextBox();
 867     if (box == m_lastTextBox)
 868         m_lastTextBox = box->prevTextBox();
 869     if (box->nextTextBox())
 870         box->nextTextBox()->setPreviousLineBox(box->prevTextBox());
 871     if (box->prevTextBox())
 872         box->prevTextBox()->setNextLineBox(box->nextTextBox());
 873 }
 874
 875 void RenderText::deleteTextBoxes()
 876 {
 877     if (firstTextBox()) {
 878         RenderArena* arena = renderArena();
 879         InlineTextBox *curr = firstTextBox(), *next = 0;
 880         while (curr) {
 881             next = curr->nextTextBox();
 882             curr->detach(arena);
 883             curr = next;
 884         }
 885         m_firstTextBox = m_lastTextBox = 0;
 886     }
 887 }
 888
 889 bool RenderText::isTextFragment() const
 890 {
 891     return false;
 892 }
 893
 894 DOM::DOMStringImpl* RenderText::originalString() const
 895 {
 896     return element() ? element()->string() : 0;
 897 }
 898
 899 void RenderText::absoluteRects(QValueList<QRect>& rects, int _tx, int _ty)
 900 {
 901     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
 902         rects.append(QRect(_tx + box->xPos(),
 903                            _ty + box->yPos(),
 904                            box->width(),
 905                            box->height()));
 906 }
 907
 908 InlineTextBox* RenderText::findNextInlineTextBox(int offset, int &pos) const
 909 {
 910     // The text runs point to parts of the rendertext's str string
 911     // (they don't include '\n')
 912     // Find the text run that includes the character at @p offset
 913     // and return pos, which is the position of the char in the run.
 914
 915     if (!m_firstTextBox)
 916         return 0;
 917
 918     InlineTextBox* s = m_firstTextBox;
 919     int off = s->m_len;
 920     while (offset > off && s->nextTextBox())
 921     {
 922         s = s->nextTextBox();
 923         off = s->m_start + s->m_len;
 924     }
 925     // we are now in the correct text run
 926     pos = (offset > off ? s->m_len : s->m_len - (off - offset) );
 927     return s;
 928 }
 929
 930 VisiblePosition RenderText::positionForCoordinates(int _x, int _y)
 931 {
 932     if (!firstTextBox() || stringLength() == 0)
 933         return VisiblePosition(element(), 0, DOWNSTREAM);
 934
 935     int absx, absy;
 936     containingBlock()->absolutePosition(absx, absy);
 937
 938     if (firstTextBox() && _y < absy + firstTextBox()->root()->bottomOverflow() && _x < absx + firstTextBox()->m_x) {
 939         // at the y coordinate of the first line or above
 940         // and the x coordinate is to the left than the first text box left edge
 941         return VisiblePosition(element(), firstTextBox()->m_start, DOWNSTREAM);
 942     }
 943
 944     if (lastTextBox() && _y >= absy + lastTextBox()->root()->topOverflow() && _x >= absx + lastTextBox()->m_x + lastTextBox()->m_width) {
 945         // at the y coordinate of the last line or below
 946         // and the x coordinate is to the right than the last text box right edge
 947         return VisiblePosition(element(), lastTextBox()->m_start + lastTextBox()->m_len, DOWNSTREAM);
 948     }
 949
 950     for (InlineTextBox *box = firstTextBox(); box; box = box->nextTextBox()) {
 951         if (_y >= absy + box->root()->topOverflow() && _y < absy + box->root()->bottomOverflow()) {
 952             if (_x < absx + box->m_x + box->m_width) {
 953                 // and the x coordinate is to the left of the right edge of this box
 954                 // check to see if position goes in this box
 955                 int offset = box->offsetForPosition(_x - absx);
 956                 if (offset != -1) {
 957                     EAffinity affinity = offset >= box->m_len && !box->nextOnLine() ? UPSTREAM : DOWNSTREAM;
 958                     VisiblePosition result = VisiblePosition(element(), offset + box->m_start, affinity);
 959                     setAffinityUsingLinePosition(result);
 960                     return result;
 961                 }
 962             }
 963             else if (!box->prevOnLine() && _x < absx + box->m_x) {
 964                 // box is first on line
 965                 // and the x coordinate is to the left of the first text box left edge
 966                 return VisiblePosition(element(), box->m_start, DOWNSTREAM);
 967             }
 968             else if (!box->nextOnLine() && _x >= absx + box->m_x + box->m_width) {
 969                 // box is last on line
 970                 // and the x coordinate is to the right of the last text box right edge
 971                 VisiblePosition result = VisiblePosition(element(), box->m_start + box->m_len, UPSTREAM);
 972                 setAffinityUsingLinePosition(result);
 973                 return result;
 974             }
 975         }
 976     }
 977
 978     return VisiblePosition(element(), 0, DOWNSTREAM);
 979 }
 980
 981 static RenderObject *firstRendererOnNextLine(InlineBox *box)
 982 {
 983     if (!box)
 984         return 0;
 985
 986     RootInlineBox *root = box->root();
 987     if (!root)
 988         return 0;
 989
 990     if (root->endsWithBreak())
 991         return 0;
 992
 993     RootInlineBox *nextRoot = root->nextRootBox();
 994     if (!nextRoot)
 995         return 0;
 996
 997     InlineBox *firstChild = nextRoot->firstChild();
 998     if (!firstChild)
 999         return 0;
1000
1001     return firstChild->object();
1002 }
1003
1004 static RenderObject *lastRendererOnPrevLine(InlineBox *box)
1005 {
1006     if (!box)
1007         return 0;
1008
1009     RootInlineBox *root = box->root();
1010     if (!root)
1011         return 0;
1012
1013     if (root->endsWithBreak())
1014         return 0;
1015
1016     RootInlineBox *prevRoot = root->prevRootBox();
1017     if (!prevRoot)
1018         return 0;
1019
1020     InlineBox *lastChild = prevRoot->lastChild();
1021     if (!lastChild)
1022         return 0;
1023
1024     return lastChild->object();
1025 }
1026
1027 QRect RenderText::caretRect(int offset, EAffinity affinity, int *extraWidthToEndOfLine)
1028 {
1029     if (!firstTextBox() || stringLength() == 0) {
1030         return QRect();
1031     }
1032
1033     // Find the text box for the given offset
1034     InlineTextBox *box = 0;
1035     for (box = firstTextBox(); box; box = box->nextTextBox()) {
1036         if ((offset >= box->m_start) && (offset <= box->m_start + box->m_len)) {
1037             // Check if downstream affinity would make us move to the next line.
1038             InlineTextBox *nextBox = box->nextTextBox();
1039             if (offset == box->m_start + box->m_len && affinity == DOWNSTREAM  && nextBox &&  !box->nextOnLine()) {
1040                 // We're at the end of a line broken on a word boundary and affinity is downstream.
1041                 // Try to jump down to the next line.
1042                 if (nextBox) {
1043                     // Use the next text box
1044                     box = nextBox;
1045                     offset = box->m_start;
1046                 } else {
1047                     // Look on the next line
1048                     RenderObject *object = firstRendererOnNextLine(box);
1049                     if (object)
1050                         return object->caretRect(0, affinity);
1051                 }
1052             } else {
1053                 InlineTextBox *prevBox = box->prevTextBox();
1054                 if (offset == box->m_start && affinity == UPSTREAM && prevBox && !box->prevOnLine()) {
1055                     if (prevBox) {
1056                         box = prevBox;
1057                         offset = box->m_start + box->m_len;
1058                     } else {
1059                         RenderObject *object = lastRendererOnPrevLine(box);
1060                         if (object)
1061                             return object->caretRect(0, affinity);
1062                     }
1063                 }
1064             }
1065             break;
1066         }
1067     }
1068
1069     if (!box) {
1070         return QRect();
1071     }
1072
1073     int height = box->root()->bottomOverflow() - box->root()->topOverflow();
1074     int top = box->root()->topOverflow();
1075
1076     int left = box->positionForOffset(offset);
1077
1078     // FIXME: should we use the width of the root inline box or the
1079     // width of the containing block for this?
1080     if (extraWidthToEndOfLine)
1081         *extraWidthToEndOfLine = (box->root()->width() + box->root()->xPos()) - (left + 1);
1082
1083     int absx, absy;
1084     absolutePosition(absx,absy);
1085     left += absx;
1086     top += absy;
1087
1088     // FIXME: Need the +1 to match caret position of other programs on Macintosh.
1089     // Would be better to somehow derive it once we understand exactly why it's needed.
1090     left += 1;
1091
1092     RenderBlock *cb = containingBlock();
1093     int availableWidth = cb->lineWidth(top);
1094     if (style()->whiteSpace() == NORMAL)
1095         left = kMin(left, absx + box->m_x + availableWidth - 1);
1096
1097     return QRect(left, top, 1, height);
1098 }
1099
1100 void RenderText::posOfChar(int chr, int &x, int &y)
1101 {
1102     absolutePosition( x, y, false );
1103
1104     //if( chr > (int) str->l )
1105     //chr = str->l;
1106
1107     int pos;
1108     InlineTextBox * s = findNextInlineTextBox( chr, pos );
1109
1110     if ( s )
1111     {
1112         // s is the line containing the character
1113         x += s->m_x; // this is the x of the beginning of the line, but it's good enough for now
1114         y += s->m_y;
1115     }
1116 }
1117
1118 #ifdef APPLE_CHANGES
1119
1120 bool RenderText::allAscii() const
1121 {
1122     if (m_allAsciiChecked)
1123         return m_allAscii;
1124     m_allAsciiChecked = true;
1125
1126     unsigned int i;
1127     for (i = 0; i < str->l; i++){
1128         if (str->s[i].unicode() >= 0x7f){
1129             m_allAscii = false;
1130             return m_allAscii;
1131         }
1132     }
1133
1134     m_allAscii = true;
1135
1136     return m_allAscii;
1137 }
1138
1139 bool RenderText::shouldUseMonospaceCache(const Font *f) const
1140 {
1141     return (f && f->isFixedPitch() && allAscii() && !style()->htmlFont().isSmallCaps());
1142 }
1143
1144 // We cache the width of the ' ' character for <pre> text.  We could go futher
1145 // and cache a widths array for all styles, at the expense of increasing the size of the
1146 // RenderText.
1147 void RenderText::cacheWidths()
1148 {
1149     const Font *f = htmlFont( false );
1150
1151     if (shouldUseMonospaceCache(f)){
1152         float fw;
1153         QChar c(' ');
1154         f->floatCharacterWidths( &c, 1, 0, 1, 0, &fw);
1155         m_monospaceCharacterWidth = (int)fw;
1156     }
1157     else
1158         m_monospaceCharacterWidth = 0;
1159 }
1160
1161
1162 inline int RenderText::widthFromCache(const Font *f, int start, int len) const
1163 {
1164     if (m_monospaceCharacterWidth != 0){
1165         int i, w = 0;
1166         for (i = start; i < start+len; i++){
1167             int dir = str->s[i].direction();
1168             if (dir != QChar::DirNSM && dir != QChar::DirBN)
1169                 w += m_monospaceCharacterWidth;
1170         }
1171         return w;
1172     }
1173
1174     return f->width(str->s, str->l, start, len);
1175 }
1176 #ifdef XXX
1177 inline int RenderText::widthFromCache(const Font *f, int start, int len) const
1178 {
1179     if (m_monospaceCharacterWidth != 0){
1180         return len * m_monospaceCharacterWidth;
1181     }
1182
1183     return f->width(str->s, str->l, start, len);
1184 }
1185 #endif
1186
1187 #endif
1188
1189 void RenderText::trimmedMinMaxWidth(int& beginMinW, bool& beginWS,
1190                                     int& endMinW, bool& endWS,
1191                                     bool& hasBreakableChar, bool& hasBreak,
1192                                     int& beginMaxW, int& endMaxW,
1193                                     int& minW, int& maxW, bool& stripFrontSpaces)
1194 {
1195     bool isPre = style()->whiteSpace() == PRE;
1196     if (isPre)
1197         stripFrontSpaces = false;
1198
1199     int len = str->l;
1200     if (len == 0 || (stripFrontSpaces && str->containsOnlyWhitespace())) {
1201         maxW = 0;
1202         hasBreak = false;
1203         return;
1204     }
1205
1206     minW = m_minWidth;
1207     maxW = m_maxWidth;
1208     beginWS = stripFrontSpaces ? false : m_hasBeginWS;
1209     endWS = m_hasEndWS;
1210
1211     beginMinW = m_beginMinWidth;
1212     endMinW = m_endMinWidth;
1213
1214     hasBreakableChar = m_hasBreakableChar;
1215     hasBreak = m_hasBreak;
1216
1217     if (stripFrontSpaces && (str->s[0] == ' ' || (!isPre && str->s[0] == '\n'))) {
1218         const Font *f = htmlFont( false );
1219         QChar space[1]; space[0] = ' ';
1220         int spaceWidth = f->width(space, 1, 0);
1221         maxW -= spaceWidth;
1222     }
1223
1224     stripFrontSpaces = !isPre && m_hasEndWS;
1225
1226     if (style()->whiteSpace() == NOWRAP)
1227         minW = maxW;
1228     else if (minW > maxW)
1229         minW = maxW;
1230
1231     // Compute our max widths by scanning the string for newlines.
1232     if (hasBreak) {
1233         const Font *f = htmlFont( false );
1234         bool firstLine = true;
1235         beginMaxW = endMaxW = maxW;
1236         for (int i = 0; i < len; i++)
1237         {
1238             int linelen = 0;
1239             while (i+linelen < len && str->s[i+linelen] != '\n')
1240                 linelen++;
1241
1242             if (linelen)
1243             {
1244 #if !APPLE_CHANGES
1245                 endMaxW = f->width(str->s, str->l, i, linelen);
1246 #else
1247                 endMaxW = widthFromCache(f, i, linelen);
1248 #endif
1249                 if (firstLine) {
1250                     firstLine = false;
1251                     beginMaxW = endMaxW;
1252                 }
1253                 i += linelen;
1254             }
1255             else if (firstLine) {
1256                 beginMaxW = 0;
1257                 firstLine = false;
1258             }
1259
1260             if (i == len-1)
1261                 // A <pre> run that ends with a newline, as in, e.g.,
1262                 // <pre>Some text\n\n<span>More text</pre>
1263                 endMaxW = 0;
1264         }
1265     }
1266 }
1267
1268 void RenderText::calcMinMaxWidth()
1269 {
1270     KHTMLAssert( !minMaxKnown() );
1271
1272     // ### calc Min and Max width...
1273     m_minWidth = m_beginMinWidth = m_endMinWidth = 0;
1274     m_maxWidth = 0;
1275
1276     if (isBR())
1277         return;
1278
1279     int currMinWidth = 0;
1280     int currMaxWidth = 0;
1281     m_hasBreakableChar = m_hasBreak = m_hasBeginWS = m_hasEndWS = false;
1282
1283     // ### not 100% correct for first-line
1284     const Font *f = htmlFont( false );
1285     int wordSpacing = style()->wordSpacing();
1286     int len = str->l;
1287     bool ignoringSpaces = false;
1288     bool isSpace = false;
1289     bool isPre = style()->whiteSpace() == PRE;
1290     bool firstWord = true;
1291     bool firstLine = true;
1292     for(int i = 0; i < len; i++)
1293     {
1294         const QChar c = str->s[i];
1295
1296         bool previousCharacterIsSpace = isSpace;
1297
1298         bool isNewline = false;
1299         if (c == '\n') {
1300             if (isPre) {
1301                 m_hasBreak = true;
1302                 isNewline = true;
1303                 isSpace = false;
1304             }
1305             else
1306                 isSpace = true;
1307         } else {
1308             isSpace = c == ' ';
1309         }
1310
1311         if ((isSpace || isNewline) && i == 0)
1312             m_hasBeginWS = true;
1313         if ((isSpace || isNewline) && i == len-1)
1314             m_hasEndWS = true;
1315
1316         if (!ignoringSpaces && !isPre && previousCharacterIsSpace && isSpace)
1317             ignoringSpaces = true;
1318
1319         if (ignoringSpaces && !isSpace)
1320             ignoringSpaces = false;
1321
1322         if (ignoringSpaces || (i > 0 && c.unicode() == SOFT_HYPHEN)) // Ignore spaces and soft hyphens
1323             continue;
1324
1325         int wordlen = 0;
1326         while (i+wordlen < len && str->s[i+wordlen] != '\n' && str->s[i+wordlen] != ' ' &&
1327                (i+wordlen == 0 || str->s[i+wordlen].unicode() != SOFT_HYPHEN) && // Skip soft hyphens
1328                (wordlen == 0 || !isBreakable( str->s, i+wordlen, str->l)))
1329             wordlen++;
1330
1331         if (wordlen)
1332         {
1333 #if !APPLE_CHANGES
1334             int w = f->width(str->s, str->l, i, wordlen);
1335 #else
1336             int w = widthFromCache(f, i, wordlen);
1337 #endif
1338             currMinWidth += w;
1339             currMaxWidth += w;
1340
1341             bool isBreakableCharSpace = (i+wordlen < len) ? ((!isPre && str->s[i+wordlen] == '\n') ||
1342                                                              str->s[i+wordlen] == ' ') : false;
1343
1344             if (i+wordlen < len && style()->whiteSpace() == NORMAL)
1345                 m_hasBreakableChar = true;
1346
1347             // Add in wordspacing to our maxwidth, but not if this is the last word on a line or the
1348             // last word in the run.
1349             if (wordSpacing && isBreakableCharSpace && !containsOnlyWhitespace(i+wordlen, len-(i+wordlen)))
1350                 currMaxWidth += wordSpacing;
1351
1352             if (firstWord) {
1353                 firstWord = false;
1354                 // If the first character in the run is breakable, then we consider ourselves to have a beginning
1355                 // minimum width of 0, since a break could occur right before our run starts, preventing us from ever
1356                 // being appended to a previous text run when considering the total minimum width of the containing block.
1357                 bool hasBreak = isBreakable(str->s, i, str->l);
1358                 if (hasBreak)
1359                     m_hasBreakableChar = true;
1360                 m_beginMinWidth = hasBreak ? 0 : w;
1361             }
1362             m_endMinWidth = w;
1363
1364             if (currMinWidth > m_minWidth) m_minWidth = currMinWidth;
1365             currMinWidth = 0;
1366
1367             i += wordlen-1;
1368         }
1369         else {
1370             // Nowrap can never be broken, so don't bother setting the
1371             // breakable character boolean. Pre can only be broken if we encounter a newline.
1372             if (style()->whiteSpace() == NORMAL || isNewline)
1373                 m_hasBreakableChar = true;
1374
1375             if (currMinWidth > m_minWidth) m_minWidth = currMinWidth;
1376             currMinWidth = 0;
1377
1378             if (isNewline) // Only set if isPre was true and we saw a newline.
1379             {
1380                 if (firstLine) {
1381                     firstLine = false;
1382                     m_beginMinWidth = currMaxWidth;
1383                 }
1384
1385                 if (currMaxWidth > m_maxWidth) m_maxWidth = currMaxWidth;
1386                 currMaxWidth = 0;
1387             }
1388             else
1389             {
1390                 currMaxWidth += f->width( str->s, str->l, i + wordlen );
1391             }
1392         }
1393     }
1394
1395     if(currMinWidth > m_minWidth) m_minWidth = currMinWidth;
1396     if(currMaxWidth > m_maxWidth) m_maxWidth = currMaxWidth;
1397
1398     if (style()->whiteSpace() != NORMAL)
1399         m_minWidth = m_maxWidth;
1400
1401     if (isPre) {
1402         if (firstLine)
1403             m_beginMinWidth = m_maxWidth;
1404         m_endMinWidth = currMaxWidth;
1405     }
1406
1407     setMinMaxKnown();
1408     //kdDebug( 6040 ) << "Text::calcMinMaxWidth(): min = " << m_minWidth << " max = " << m_maxWidth << endl;
1409 }
1410
1411 bool RenderText::containsOnlyWhitespace(unsigned int from, unsigned int len) const
1412 {
1413     unsigned int currPos;
1414     for (currPos = from;
1415          currPos < from+len && (str->s[currPos] == '\n' || str->s[currPos].unicode() == ' ');
1416          currPos++);
1417     return currPos >= (from+len);
1418 }
1419
1420 int RenderText::minXPos() const
1421 {
1422     if (!m_firstTextBox) return 0;
1423     int retval=6666666;
1424     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
1425         retval = kMin(retval, (int)box->m_x);
1426     return retval;
1427 }
1428
1429 int RenderText::xPos() const
1430 {
1431     return m_firstTextBox ? m_firstTextBox->m_x : 0;
1432 }
1433
1434 int RenderText::yPos() const
1435 {
1436     return m_firstTextBox ? m_firstTextBox->m_y : 0;
1437 }
1438
1439 const QFont &RenderText::font()
1440 {
1441     return style()->font();
1442 }
1443
1444 void RenderText::setSelectionState(SelectionState s)
1445 {
1446     InlineTextBox* box;
1447
1448     m_selectionState = s;
1449     if (s == SelectionStart || s == SelectionEnd || s == SelectionBoth) {
1450         int startPos, endPos;
1451         selectionStartEnd(startPos, endPos);
1452         if(selectionState() == SelectionStart) {
1453             endPos = str->l;
1454
1455             // to handle selection from end of text to end of line
1456             if (startPos != 0 && startPos == endPos) {
1457                 startPos = endPos - 1;
1458             }
1459         } else if(selectionState() == SelectionEnd)
1460             startPos = 0;
1461
1462         for (box = firstTextBox(); box; box = box->nextTextBox()) {
1463             if (box->isSelected(startPos, endPos)) {
1464                 RootInlineBox* line = box->root();
1465                 if (line)
1466                     line->setHasSelectedChildren(true);
1467             }
1468         }
1469     }
1470     else {
1471         for (box = firstTextBox(); box; box = box->nextTextBox()) {
1472             RootInlineBox* line = box->root();
1473             if (line)
1474                 line->setHasSelectedChildren(s == SelectionInside);
1475         }
1476     }
1477
1478     containingBlock()->setSelectionState(s);
1479 }
1480
1481 void RenderText::setTextWithOffset(DOMStringImpl *text, uint offset, uint len, bool force)
1482 {
1483     uint oldLen = str ? str->l : 0;
1484     uint newLen = text ? text->l : 0;
1485     int delta = newLen - oldLen;
1486     uint end = len ? offset+len-1 : offset;
1487
1488     RootInlineBox* firstRootBox = 0;
1489     RootInlineBox* lastRootBox = 0;
1490
1491     bool dirtiedLines = false;
1492
1493     // Dirty all text boxes that include characters in between offset and offset+len.
1494     for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
1495         // Text run is entirely before the affected range.
1496         if (curr->end() < offset)
1497             continue;
1498
1499         // Text run is entirely after the affected range.
1500         if (curr->start() > end) {
1501             curr->offsetRun(delta);
1502             RootInlineBox* root = curr->root();
1503             if (!firstRootBox) {
1504                 firstRootBox = root;
1505                 if (!dirtiedLines) { // The affected area was in between two runs. Go ahead and mark the root box of the run after the affected area as dirty.
1506                     firstRootBox->markDirty();
1507                     dirtiedLines = true;
1508                 }
1509             }
1510             lastRootBox = root;
1511         }
1512         else if (curr->end() >= offset && curr->end() <= end) {
1513             curr->dirtyLineBoxes(); // Text run overlaps with the left end of the affected range.
1514             dirtiedLines = true;
1515         }
1516         else if (curr->start() <= offset && curr->end() >= end) {
1517             curr->dirtyLineBoxes(); // Text run subsumes the affected range.
1518             dirtiedLines = true;
1519         }
1520         else if (curr->start() <= end && curr->end() >= end) {
1521             curr->dirtyLineBoxes(); // Text run overlaps with right end of the affected range.
1522             dirtiedLines = true;
1523         }
1524     }
1525
1526     // Now we have to walk all of the clean lines and adjust their cached line break information
1527     // to reflect our updated offsets.
1528     if (lastRootBox)
1529         lastRootBox = lastRootBox->nextRootBox();
1530     if (firstRootBox) {
1531         RootInlineBox* prev = firstRootBox->prevRootBox();
1532         if (prev)
1533             firstRootBox = prev;
1534     }
1535     for (RootInlineBox* curr = firstRootBox; curr && curr != lastRootBox; curr = curr->nextRootBox()) {
1536         if (curr->lineBreakObj() == this && curr->lineBreakPos() > end)
1537             curr->setLineBreakPos(curr->lineBreakPos()+delta);
1538     }
1539
1540     m_linesDirty = dirtiedLines;
1541     setText(text, force);
1542 }
1543
1544 void RenderText::setText(DOMStringImpl *text, bool force)
1545 {
1546     if (!text)
1547         return;
1548     if (!force && str == text)
1549         return;
1550     if (str)
1551         str->deref();
1552
1553 #ifdef APPLE_CHANGES
1554     m_allAsciiChecked = false;
1555 #endif
1556
1557     str = text;
1558     if (str) {
1559         str = str->replace('\\', backslashAsCurrencySymbol());
1560         if ( style() ) {
1561             switch(style()->textTransform()) {
1562                 case CAPITALIZE:   str = str->capitalize();  break;
1563                 case UPPERCASE:   str = str->upper();       break;
1564                 case LOWERCASE:  str = str->lower();       break;
1565                 case NONE:
1566                 default:;
1567             }
1568         }
1569         str->ref();
1570     }
1571
1572 #if APPLE_CHANGES
1573     cacheWidths();
1574 #endif
1575
1576     // ### what should happen if we change the text of a
1577     // RenderBR object ?
1578     KHTMLAssert(!isBR() || (str->l == 1 && (*str->s) == '\n'));
1579     KHTMLAssert(!str->l || str->s);
1580
1581     setNeedsLayoutAndMinMaxRecalc();
1582
1583 #ifdef BIDI_DEBUG
1584     QConstString cstr(str->s, str->l);
1585     kdDebug( 6040 ) << "RenderText::setText( " << cstr.string().length() << " ) '" << cstr.string() << "'" << endl;
1586 #endif
1587 }
1588
1589 int RenderText::height() const
1590 {
1591     // FIXME: Why use line-height? Shouldn't we be adding in the height of the last text box? -dwh
1592     int retval = 0;
1593     if (firstTextBox())
1594         retval = lastTextBox()->m_y + lineHeight(false) - firstTextBox()->m_y;
1595     return retval;
1596 }
1597
1598 short RenderText::lineHeight(bool firstLine, bool) const
1599 {
1600     // Always use the interior line height of the parent (e.g., if our parent is an inline block).
1601     return parent()->lineHeight(firstLine, true);
1602 }
1603
1604 short RenderText::baselinePosition( bool firstLine, bool ) const
1605 {
1606     const QFontMetrics &fm = metrics( firstLine );
1607     return fm.ascent() +
1608         ( lineHeight( firstLine ) - fm.height() ) / 2;
1609 }
1610
1611 void RenderText::dirtyLineBoxes(bool fullLayout, bool)
1612 {
1613     if (fullLayout)
1614         deleteTextBoxes();
1615     else if (!m_linesDirty) {
1616         for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
1617             box->dirtyLineBoxes();
1618     }
1619     m_linesDirty = false;
1620 }
1621
1622 InlineBox* RenderText::createInlineBox(bool, bool isRootLineBox, bool)
1623 {
1624     KHTMLAssert(!isRootLineBox);
1625     InlineTextBox* textBox = new (renderArena()) InlineTextBox(this);
1626     if (!m_firstTextBox)
1627         m_firstTextBox = m_lastTextBox = textBox;
1628     else {
1629         m_lastTextBox->setNextLineBox(textBox);
1630         textBox->setPreviousLineBox(m_lastTextBox);
1631         m_lastTextBox = textBox;
1632     }
1633     return textBox;
1634 }
1635
1636 void RenderText::position(InlineBox* box, int from, int len, bool reverse)
1637 {
1638     InlineTextBox *s = static_cast<InlineTextBox*>(box);
1639
1640     // ### should not be needed!!!
1641     if (len == 0) {
1642         // We want the box to be destroyed.
1643         s->remove();
1644         s->detach(renderArena());
1645         m_firstTextBox = m_lastTextBox = 0;
1646         return;
1647     }
1648
1649     reverse = reverse && !style()->visuallyOrdered();
1650
1651 #ifdef DEBUG_LAYOUT
1652     QChar *ch = str->s+from;
1653     QConstString cstr(ch, len);
1654     qDebug("setting run text to *%s*, len=%d, w)=%d" , cstr.string().latin1(), len, width );//" << y << ")" << " height=" << lineHeight(false) << " fontHeight=" << metrics(false).height() << " ascent =" << metrics(false).ascent() << endl;
1655 #endif
1656
1657     s->m_reversed = reverse;
1658     s->m_start = from;
1659     s->m_len = len;
1660 }
1661
1662 unsigned int RenderText::width(unsigned int from, unsigned int len, bool firstLine) const
1663 {
1664     if(!str->s || from > str->l ) return 0;
1665     if ( from + len > str->l ) len = str->l - from;
1666
1667     const Font *f = htmlFont( firstLine );
1668     return width( from, len, f );
1669 }
1670
1671 unsigned int RenderText::width(unsigned int from, unsigned int len, const Font *f) const
1672 {
1673     if(!str->s || from > str->l ) return 0;
1674     if ( from + len > str->l ) len = str->l - from;
1675
1676     int w;
1677     if ( f == &style()->htmlFont() && from == 0 && len == str->l )
1678         w = m_maxWidth;
1679 #if APPLE_CHANGES
1680     else if (f == &style()->htmlFont())
1681         w = widthFromCache (f, from, len);
1682 #endif
1683     else
1684         w = f->width(str->s, str->l, from, len );
1685
1686     //kdDebug( 6040 ) << "RenderText::width(" << from << ", " << len << ") = " << w << endl;
1687     return w;
1688 }
1689
1690 int RenderText::width() const
1691 {
1692     int w;
1693     int minx = 100000000;
1694     int maxx = 0;
1695     // slooow
1696     for (InlineTextBox* s = firstTextBox(); s; s = s->nextTextBox()) {
1697         if(s->m_x < minx)
1698             minx = s->m_x;
1699         if(s->m_x + s->m_width > maxx)
1700             maxx = s->m_x + s->m_width;
1701     }
1702
1703     w = kMax(0, maxx-minx);
1704
1705     return w;
1706 }
1707
1708 QRect RenderText::getAbsoluteRepaintRect()
1709 {
1710     RenderObject *cb = containingBlock();
1711     return cb->getAbsoluteRepaintRect();
1712 }
1713
1714 QRect RenderText::selectionRect()
1715 {
1716     QRect rect;
1717     if (selectionState() == SelectionNone)
1718         return rect;
1719     RenderBlock* cb =  containingBlock();
1720     if (!cb)
1721         return rect;
1722
1723     // Now calculate startPos and endPos for painting selection.
1724     // We include a selection while endPos > 0
1725     int startPos, endPos;
1726     if (selectionState() == SelectionInside) {
1727         // We are fully selected.
1728         startPos = 0;
1729         endPos = str->l;
1730     } else {
1731         selectionStartEnd(startPos, endPos);
1732         if (selectionState() == SelectionStart)
1733             endPos = str->l;
1734         else if (selectionState() == SelectionEnd)
1735             startPos = 0;
1736     }
1737
1738     if (startPos == endPos)
1739         return rect;
1740
1741     int absx, absy;
1742     cb->absolutePosition(absx, absy);
1743     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
1744         QRect r = box->selectionRect(absx, absy, startPos, endPos);
1745         if (!r.isEmpty()) {
1746             if (rect.isEmpty())
1747                 rect = r;
1748             else
1749                 rect = rect.unite(r);
1750         }
1751     }
1752
1753     return rect;
1754 }
1755
1756 short RenderText::verticalPositionHint( bool firstLine ) const
1757 {
1758     return parent()->verticalPositionHint( firstLine );
1759 }
1760
1761 const QFontMetrics &RenderText::metrics(bool firstLine) const
1762 {
1763     return style(firstLine)->fontMetrics();
1764 }
1765
1766 const Font *RenderText::htmlFont(bool firstLine) const
1767 {
1768     return &style(firstLine)->htmlFont();
1769 }
1770
1771 long RenderText::caretMinOffset() const
1772 {
1773     InlineTextBox *box = firstTextBox();
1774     if (!box)
1775         return 0;
1776     int minOffset = box->m_start;
1777     for (box = box->nextTextBox(); box; box = box->nextTextBox())
1778         minOffset = kMin(minOffset, box->m_start);
1779     return minOffset;
1780 }
1781
1782 long RenderText::caretMaxOffset() const
1783 {
1784     InlineTextBox* box = lastTextBox();
1785     if (!box)
1786         return str->l;
1787     int maxOffset = box->m_start + box->m_len;
1788     for (box = box->prevTextBox(); box; box = box->prevTextBox())
1789         maxOffset = kMax(maxOffset,box->m_start + box->m_len);
1790     return maxOffset;
1791 }
1792
1793 unsigned long RenderText::caretMaxRenderedOffset() const
1794 {
1795     int l = 0;
1796     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
1797         l += box->m_len;
1798     return l;
1799 }
1800
1801 InlineBox *RenderText::inlineBox(long offset, EAffinity affinity)
1802 {
1803     for (InlineTextBox *box = firstTextBox(); box; box = box->nextTextBox()) {
1804         if (offset >= box->m_start && offset <= box->m_start + box->m_len) {
1805             if (affinity == DOWNSTREAM && box->nextTextBox() && offset == box->m_start + box->m_len)
1806                 return box->nextTextBox();
1807             return box;
1808         }
1809         else if (offset < box->m_start) {
1810             // The offset we're looking for is before this node
1811             // this means the offset must be in content that is
1812             // not rendered.
1813             return box->prevTextBox() ? box->prevTextBox() : firstTextBox();
1814         }
1815     }
1816
1817     return 0;
1818 }
1819
1820 RenderTextFragment::RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str,
1821                                        int startOffset, int endOffset)
1822 :RenderText(_node, _str->substring(startOffset, endOffset)),
1823 m_start(startOffset), m_end(endOffset), m_generatedContentStr(0)
1824 {}
1825
1826 RenderTextFragment::RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str)
1827 :RenderText(_node, _str), m_start(0)
1828 {
1829     m_generatedContentStr = _str;
1830     if (_str) {
1831         _str->ref();
1832         m_end = _str->l;
1833     }
1834     else
1835         m_end = 0;
1836 }
1837
1838 RenderTextFragment::~RenderTextFragment()
1839 {
1840     if (m_generatedContentStr)
1841         m_generatedContentStr->deref();
1842 }
1843
1844 bool RenderTextFragment::isTextFragment() const
1845 {
1846     return true;
1847 }
1848
1849 DOM::DOMStringImpl* RenderTextFragment::originalString() const
1850 {
1851     DOM::DOMStringImpl* result = 0;
1852     if (element())
1853         result = element()->string();
1854     else
1855         result = contentString();
1856     if (result && (start() > 0 || start() < result->l))
1857         result = result->substring(start(), end());
1858     return result;
1859 }
1860 #undef BIDI_DEBUG
1861 #undef DEBUG_LAYOUT