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