f8019ded88365b1e4d37ca84c1e420c56578138a
[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_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, m_x);
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 need to measure.
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, textObject()->tabWidth(), textPos(),
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, textObject()->tabWidth(), textPos(),
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()->tabWidth(), textPos(),
401                                    textObject()->string()->s, 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()->tabWidth(), textPos(),
406                                    textObject()->string()->s, 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()->tabWidth(), textPos(),
423                            textObject()->string()->s, 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 y = r->selectionTop();
528     int h = r->selectionHeight();
529     f->drawHighlightForText(p, m_x + tx, y + ty, h, textObject()->tabWidth(), textPos(), 
530                             textObject()->str->s, textObject()->str->l, m_start, m_len,
531                             m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, style->visuallyOrdered(), sPos, ePos, c);
532     p->restore();
533 }
534
535 void InlineTextBox::paintMarkedTextBackground(QPainter* p, int tx, int ty, RenderStyle* style, const Font* f, int startPos, int endPos)
536 {
537     int offset = m_start;
538     int sPos = kMax(startPos - offset, 0);
539     int ePos = kMin(endPos - offset, (int)m_len);
540
541     if (sPos >= ePos)
542         return;
543
544     p->save();
545
546     QColor c = QColor(225, 221, 85);
547     
548     p->setPen(c); // Don't draw text at all!
549
550     RootInlineBox* r = root();
551     int y = r->selectionTop();
552     int h = r->selectionHeight();
553     f->drawHighlightForText(p, m_x + tx, y + ty, h, textObject()->tabWidth(), textPos(), textObject()->str->s, textObject()->str->l, m_start, m_len,
554             m_toAdd, m_reversed ? QPainter::RTL : QPainter::LTR, style->visuallyOrdered(), sPos, ePos, c);
555     p->restore();
556 }
557
558 void InlineTextBox::paintDecoration( QPainter *pt, int _tx, int _ty, int deco)
559 {
560     _tx += m_x;
561     _ty += m_y;
562
563     if (m_truncation == cFullTruncation)
564         return;
565     
566     int width = (m_truncation == cNoTruncation) ? 
567                 m_width : static_cast<RenderText*>(m_object)->width(m_start, m_truncation - m_start, m_firstLine);
568     
569     // Get the text decoration colors.
570     QColor underline, overline, linethrough;
571     object()->getTextDecorationColors(deco, underline, overline, linethrough, true);
572     
573     // Use a special function for underlines to get the positioning exactly right.
574     if (deco & UNDERLINE) {
575         pt->setPen(underline);
576         pt->drawLineForText(_tx, _ty, m_baseline, width);
577     }
578     if (deco & OVERLINE) {
579         pt->setPen(overline);
580         pt->drawLineForText(_tx, _ty, 0, width);
581     }
582     if (deco & LINE_THROUGH) {
583         pt->setPen(linethrough);
584         pt->drawLineForText(_tx, _ty, 2*m_baseline/3, width);
585     }
586 }
587
588 void InlineTextBox::paintMarker(QPainter *pt, int _tx, int _ty, DocumentMarker marker)
589 {
590     _tx += m_x;
591     _ty += m_y;
592
593     if (m_truncation == cFullTruncation)
594         return;
595     
596     int start = 0;                  // start of line to draw, relative to _tx
597     int width = m_width;            // how much line to draw
598     bool useWholeWidth = true;
599     ulong paintStart = m_start;
600     ulong paintEnd = end()+1;      // end points at the last char, not past it
601     if (paintStart <= marker.startOffset) {
602         paintStart = marker.startOffset;
603         useWholeWidth = false;
604         start = static_cast<RenderText*>(m_object)->width(m_start, paintStart - m_start, m_firstLine);
605     }
606     if (paintEnd != marker.endOffset) {      // end points at the last char, not past it
607         paintEnd = kMin(paintEnd, marker.endOffset);
608         useWholeWidth = false;
609     }
610     if (m_truncation != cNoTruncation) {
611         paintEnd = kMin(paintEnd, (ulong)m_truncation);
612         useWholeWidth = false;
613     }
614     if (!useWholeWidth) {
615         width = static_cast<RenderText*>(m_object)->width(paintStart, paintEnd - paintStart, m_firstLine);
616     }
617
618     // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
619     // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
620     // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
621     // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
622     // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
623     // we pin to two pixels under the baseline.
624     int lineThickness = pt->misspellingLineThickness();
625     int descent = m_height - m_baseline;
626     int underlineOffset;
627     if (descent <= (2 + lineThickness)) {
628         // place the underline at the very bottom of the text in small/medium fonts
629         underlineOffset = m_height - lineThickness;
630     } else {
631         // in larger fonts, tho, place the underline up near the baseline to prevent big gap
632         underlineOffset = m_baseline + 2;
633     }
634     pt->drawLineForMisspelling(_tx + start, _ty + underlineOffset, width);
635 }
636
637 void InlineTextBox::paintMarkedTextUnderline(QPainter *pt, int _tx, int _ty, KWQKHTMLPart::MarkedTextUnderline underline)
638 {
639     _tx += m_x;
640     _ty += m_y;
641
642     if (m_truncation == cFullTruncation)
643         return;
644     
645     int start = 0;                  // start of line to draw, relative to _tx
646     int width = m_width;            // how much line to draw
647     bool useWholeWidth = true;
648     ulong paintStart = m_start;
649     ulong paintEnd = end()+1;      // end points at the last char, not past it
650     if (paintStart <= underline.startOffset) {
651         paintStart = underline.startOffset;
652         useWholeWidth = false;
653         start = static_cast<RenderText*>(m_object)->width(m_start, paintStart - m_start, m_firstLine);
654     }
655     if (paintEnd != underline.endOffset) {      // end points at the last char, not past it
656         paintEnd = kMin(paintEnd, (ulong)underline.endOffset);
657         useWholeWidth = false;
658     }
659     if (m_truncation != cNoTruncation) {
660         paintEnd = kMin(paintEnd, (ulong)m_truncation);
661         useWholeWidth = false;
662     }
663     if (!useWholeWidth) {
664         width = static_cast<RenderText*>(m_object)->width(paintStart, paintEnd - paintStart, m_firstLine);
665     }
666
667     int underlineOffset = m_height - 3;
668     pt->setPen(QPen(underline.color, underline.thick ? 2 : 0));
669     pt->drawLineForText(_tx + start, _ty, underlineOffset, width);
670 }
671
672 long InlineTextBox::caretMinOffset() const
673 {
674     return m_start;
675 }
676
677 long InlineTextBox::caretMaxOffset() const
678 {
679     return m_start + m_len;
680 }
681
682 unsigned long InlineTextBox::caretMaxRenderedOffset() const
683 {
684     return m_start + m_len;
685 }
686
687 static UBreakIterator *getCharacterBreakIterator(const DOMStringImpl *i)
688 {
689     // The locale is currently ignored when determining character cluster breaks.  This may change
690     // in the future (according to Deborah Goldsmith).
691     static bool createdIterator = false;
692     static UBreakIterator *iterator;
693     UErrorCode status;
694     if (!createdIterator) {
695         status = U_ZERO_ERROR;
696         iterator = ubrk_open(UBRK_CHARACTER, "en_us", NULL, 0, &status);
697         createdIterator = true;
698     }
699     if (!iterator) {
700         return NULL;
701     }
702     status = U_ZERO_ERROR;
703     ubrk_setText(iterator, reinterpret_cast<const UChar *>(i->s), i->l, &status);
704     if (status != U_ZERO_ERROR) {
705         return NULL;
706     }
707     return iterator;
708 }
709
710 long RenderText::previousOffset (long current) const
711 {
712     UBreakIterator *iterator = getCharacterBreakIterator(str);
713     if (iterator) {
714         return ubrk_preceding(iterator, current);
715     }
716     return current - 1;
717 }
718
719 long RenderText::nextOffset (long current) const
720 {
721     UBreakIterator *iterator = getCharacterBreakIterator(str);
722     if (iterator) {
723         return ubrk_following(iterator, current);
724     }
725     return current + 1;
726 }
727
728 int InlineTextBox::textPos() const
729 {
730     if (xPos() == 0)
731         return 0;
732         
733     RenderBlock *blockElement = object()->containingBlock();
734     return m_reversed ? xPos() - blockElement->borderRight() - blockElement->paddingRight()
735                       : xPos() - blockElement->borderLeft() - blockElement->paddingLeft();
736 }
737
738 int InlineTextBox::offsetForPosition(int _x, bool includePartialGlyphs) const
739 {
740     RenderText* text = static_cast<RenderText*>(m_object);
741     const Font* f = text->htmlFont(m_firstLine);
742     return f->checkSelectionPoint(text->str->s, text->str->l, m_start, m_len, m_toAdd, text->tabWidth(), textPos(), _x - m_x, m_reversed, includePartialGlyphs);
743 }
744
745 int InlineTextBox::positionForOffset(int offset) const
746 {
747     RenderText *text = static_cast<RenderText *>(m_object);
748     const QFontMetrics &fm = text->metrics(m_firstLine);
749
750     int left;
751     if (m_reversed) {
752         long len = m_start + m_len - offset;
753         QString string(text->str->s + offset, len);
754         left = m_x + fm.boundingRect(string, text->tabWidth(), textPos(), len).right();
755     } else {
756         long len = offset - m_start;
757         QString string(text->str->s + m_start, len);
758         left = m_x + fm.boundingRect(string, text->tabWidth(), textPos(), len).right();
759     }
760     // FIXME: Do we need to add rightBearing here?
761     return left;
762 }
763
764 // -------------------------------------------------------------------------------------
765
766 RenderText::RenderText(DOM::NodeImpl* node, DOMStringImpl *_str)
767     : RenderObject(node), m_linesDirty(false)
768 {
769     // init RenderObject attributes
770     setRenderText();   // our object inherits from RenderText
771
772     m_minWidth = -1;
773     m_maxWidth = -1;
774
775 #ifdef APPLE_CHANGES
776     m_monospaceCharacterWidth = 0;
777     m_allAsciiChecked = false;
778     m_allAscii = false;
779 #endif
780
781     str = _str;
782     if (str) {
783         str = str->replace('\\', backslashAsCurrencySymbol());
784         str->ref();
785     }
786     KHTMLAssert(!str || !str->l || str->s);
787
788     m_firstTextBox = m_lastTextBox = 0;
789     
790     m_selectionState = SelectionNone;
791
792 #ifdef DEBUG_LAYOUT
793     QConstString cstr(str->s, str->l);
794     kdDebug( 6040 ) << "RenderText ctr( "<< cstr.string().length() << " )  '" << cstr.string() << "'" << endl;
795 #endif
796 }
797
798 void RenderText::setStyle(RenderStyle *_style)
799 {
800     if ( style() != _style ) {
801         bool needToTransformText = (!style() && _style->textTransform() != TTNONE) ||
802                                    (style() && style()->textTransform() != _style->textTransform());
803
804         RenderObject::setStyle( _style );
805
806         if (needToTransformText) {
807             DOM::DOMStringImpl* textToTransform = originalString();
808             if (textToTransform)
809                 setText(textToTransform, true);
810         }
811 #if APPLE_CHANGES
812         // setText also calls cacheWidths(), so there is no need to call it again in that case.
813         else
814             cacheWidths();
815 #endif
816     }
817 }
818
819 RenderText::~RenderText()
820 {
821     if(str) str->deref();
822 }
823
824 void RenderText::detach()
825 {
826     if (!documentBeingDestroyed()) {
827         if (firstTextBox()) {
828             if (isBR()) {
829                 RootInlineBox* next = firstTextBox()->root()->nextRootBox();
830                 if (next)
831                     next->markDirty();
832             }
833             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
834                 box->remove();
835         }
836         else if (parent())
837             parent()->dirtyLinesFromChangedChild(this);
838     }
839     deleteTextBoxes();
840     RenderObject::detach();
841 }
842
843 void RenderText::extractTextBox(InlineTextBox* box)
844 {
845     m_lastTextBox = box->prevTextBox();
846     if (box == m_firstTextBox)
847         m_firstTextBox = 0;
848     if (box->prevTextBox())
849         box->prevTextBox()->setNextLineBox(0);
850     box->setPreviousLineBox(0);
851     for (InlineRunBox* curr = box; curr; curr = curr->nextLineBox())
852         curr->setExtracted();
853 }
854
855 void RenderText::attachTextBox(InlineTextBox* box)
856 {
857     if (m_lastTextBox) {
858         m_lastTextBox->setNextLineBox(box);
859         box->setPreviousLineBox(m_lastTextBox);
860     }
861     else
862         m_firstTextBox = box;
863     InlineTextBox* last = box;
864     for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox()) {
865         curr->setExtracted(false);
866         last = curr;
867     }
868     m_lastTextBox = last;
869 }
870
871 void RenderText::removeTextBox(InlineTextBox* box)
872 {
873     if (box == m_firstTextBox)
874         m_firstTextBox = box->nextTextBox();
875     if (box == m_lastTextBox)
876         m_lastTextBox = box->prevTextBox();
877     if (box->nextTextBox())
878         box->nextTextBox()->setPreviousLineBox(box->prevTextBox());
879     if (box->prevTextBox())
880         box->prevTextBox()->setNextLineBox(box->nextTextBox());
881 }
882
883 void RenderText::deleteTextBoxes()
884 {
885     if (firstTextBox()) {
886         RenderArena* arena = renderArena();
887         InlineTextBox *curr = firstTextBox(), *next = 0;
888         while (curr) {
889             next = curr->nextTextBox();
890             curr->detach(arena);
891             curr = next;
892         }
893         m_firstTextBox = m_lastTextBox = 0;
894     }
895 }
896
897 bool RenderText::isTextFragment() const
898 {
899     return false;
900 }
901
902 DOM::DOMStringImpl* RenderText::originalString() const
903 {
904     return element() ? element()->string() : 0;
905 }
906
907 void RenderText::absoluteRects(QValueList<QRect>& rects, int _tx, int _ty)
908 {
909     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
910         rects.append(QRect(_tx + box->xPos(), 
911                            _ty + box->yPos(), 
912                            box->width(), 
913                            box->height()));
914 }
915
916 InlineTextBox* RenderText::findNextInlineTextBox(int offset, int &pos) const
917 {
918     // The text runs point to parts of the rendertext's str string
919     // (they don't include '\n')
920     // Find the text run that includes the character at @p offset
921     // and return pos, which is the position of the char in the run.
922
923     if (!m_firstTextBox)
924         return 0;
925     
926     InlineTextBox* s = m_firstTextBox;
927     int off = s->m_len;
928     while (offset > off && s->nextTextBox())
929     {
930         s = s->nextTextBox();
931         off = s->m_start + s->m_len;
932     }
933     // we are now in the correct text run
934     pos = (offset > off ? s->m_len : s->m_len - (off - offset) );
935     return s;
936 }
937
938 VisiblePosition RenderText::positionForCoordinates(int _x, int _y)
939 {
940     if (!firstTextBox() || stringLength() == 0)
941         return VisiblePosition(element(), 0, DOWNSTREAM);
942
943     int absx, absy;
944     containingBlock()->absolutePosition(absx, absy);
945
946     if (firstTextBox() && _y < absy + firstTextBox()->root()->bottomOverflow() && _x < absx + firstTextBox()->m_x) {
947         // at the y coordinate of the first line or above
948         // and the x coordinate is to the left than the first text box left edge
949         return VisiblePosition(element(), firstTextBox()->m_start, DOWNSTREAM);
950     }
951
952     if (lastTextBox() && _y >= absy + lastTextBox()->root()->topOverflow() && _x >= absx + lastTextBox()->m_x + lastTextBox()->m_width) {
953         // at the y coordinate of the last line or below
954         // and the x coordinate is to the right than the last text box right edge
955         return VisiblePosition(element(), lastTextBox()->m_start + lastTextBox()->m_len, DOWNSTREAM);
956     }
957
958     for (InlineTextBox *box = firstTextBox(); box; box = box->nextTextBox()) {
959         if (_y >= absy + box->root()->topOverflow() && _y < absy + box->root()->bottomOverflow()) {
960             if (_x < absx + box->m_x + box->m_width) {
961                 // and the x coordinate is to the left of the right edge of this box
962                 // check to see if position goes in this box
963                 int offset = box->offsetForPosition(_x - absx);
964                 if (offset != -1) {
965                     EAffinity affinity = offset >= box->m_len && !box->nextOnLine() ? UPSTREAM : DOWNSTREAM;
966                     VisiblePosition result = VisiblePosition(element(), offset + box->m_start, affinity);
967                     setAffinityUsingLinePosition(result);
968                     return result;
969                 }
970             }
971             else if (!box->prevOnLine() && _x < absx + box->m_x) {
972                 // box is first on line
973                 // and the x coordinate is to the left of the first text box left edge
974                 return VisiblePosition(element(), box->m_start, DOWNSTREAM);
975             }
976             else if (!box->nextOnLine() && _x >= absx + box->m_x + box->m_width) {
977                 // box is last on line
978                 // and the x coordinate is to the right of the last text box right edge
979                 VisiblePosition result = VisiblePosition(element(), box->m_start + box->m_len, UPSTREAM);
980                 setAffinityUsingLinePosition(result);
981                 return result;
982             }
983         }
984     }
985     
986     return VisiblePosition(element(), 0, DOWNSTREAM);
987 }
988
989 static RenderObject *firstRendererOnNextLine(InlineBox *box)
990 {
991     if (!box)
992         return 0;
993
994     RootInlineBox *root = box->root();
995     if (!root)
996         return 0;
997         
998     if (root->endsWithBreak())
999         return 0;
1000     
1001     RootInlineBox *nextRoot = root->nextRootBox();
1002     if (!nextRoot)
1003         return 0;
1004     
1005     InlineBox *firstChild = nextRoot->firstChild();
1006     if (!firstChild)
1007         return 0;
1008
1009     return firstChild->object();
1010 }
1011
1012 static RenderObject *lastRendererOnPrevLine(InlineBox *box)
1013 {
1014     if (!box)
1015         return 0;
1016     
1017     RootInlineBox *root = box->root();
1018     if (!root)
1019         return 0;
1020     
1021     if (root->endsWithBreak())
1022         return 0;
1023     
1024     RootInlineBox *prevRoot = root->prevRootBox();
1025     if (!prevRoot)
1026         return 0;
1027     
1028     InlineBox *lastChild = prevRoot->lastChild();
1029     if (!lastChild)
1030         return 0;
1031     
1032     return lastChild->object();
1033 }
1034
1035 QRect RenderText::caretRect(int offset, EAffinity affinity, int *extraWidthToEndOfLine)
1036 {
1037     if (!firstTextBox() || stringLength() == 0) {
1038         return QRect();
1039     }
1040
1041     // Find the text box for the given offset
1042     InlineTextBox *box = 0;
1043     for (box = firstTextBox(); box; box = box->nextTextBox()) {
1044         if ((offset >= box->m_start) && (offset <= box->m_start + box->m_len)) {
1045             // Check if downstream affinity would make us move to the next line.
1046             InlineTextBox *nextBox = box->nextTextBox();
1047             if (offset == box->m_start + box->m_len && affinity == DOWNSTREAM  && nextBox &&  !box->nextOnLine()) {
1048                 // We're at the end of a line broken on a word boundary and affinity is downstream.
1049                 // Try to jump down to the next line.
1050                 if (nextBox) {
1051                     // Use the next text box
1052                     box = nextBox;
1053                     offset = box->m_start;
1054                 } else {
1055                     // Look on the next line
1056                     RenderObject *object = firstRendererOnNextLine(box);
1057                     if (object)
1058                         return object->caretRect(0, affinity);
1059                 }
1060             } else {
1061                 InlineTextBox *prevBox = box->prevTextBox();
1062                 if (offset == box->m_start && affinity == UPSTREAM && prevBox && !box->prevOnLine()) {
1063                     if (prevBox) {
1064                         box = prevBox;
1065                         offset = box->m_start + box->m_len;
1066                     } else {
1067                         RenderObject *object = lastRendererOnPrevLine(box);
1068                         if (object)
1069                             return object->caretRect(0, affinity);
1070                     }
1071                 }
1072             }
1073             break;
1074         }
1075     }
1076     
1077     if (!box) {
1078         return QRect();
1079     }
1080
1081     int height = box->root()->bottomOverflow() - box->root()->topOverflow();
1082     int top = box->root()->topOverflow();
1083
1084     int left = box->positionForOffset(offset);
1085
1086     // FIXME: should we use the width of the root inline box or the
1087     // width of the containing block for this?
1088     if (extraWidthToEndOfLine)
1089         *extraWidthToEndOfLine = (box->root()->width() + box->root()->xPos()) - (left + 1);
1090
1091     int absx, absy;
1092     absolutePosition(absx,absy);
1093     left += absx;
1094     top += absy;
1095
1096     // FIXME: Need the +1 to match caret position of other programs on Macintosh.
1097     // Would be better to somehow derive it once we understand exactly why it's needed.
1098     left += 1;
1099
1100     RenderBlock *cb = containingBlock();
1101     int availableWidth = cb->lineWidth(top);
1102     if (style()->whiteSpace() == NORMAL)
1103         left = kMin(left, absx + box->m_x + availableWidth - 1);
1104     
1105     return QRect(left, top, 1, height);
1106 }
1107
1108 void RenderText::posOfChar(int chr, int &x, int &y)
1109 {
1110     absolutePosition( x, y, false );
1111
1112     //if( chr > (int) str->l )
1113     //chr = str->l;
1114
1115     int pos;
1116     InlineTextBox * s = findNextInlineTextBox( chr, pos );
1117
1118     if ( s )
1119     {
1120         // s is the line containing the character
1121         x += s->m_x; // this is the x of the beginning of the line, but it's good enough for now
1122         y += s->m_y;
1123     }
1124 }
1125
1126 #ifdef APPLE_CHANGES
1127
1128 bool RenderText::allAscii() const
1129 {
1130     if (m_allAsciiChecked)
1131         return m_allAscii;
1132     m_allAsciiChecked = true;
1133     
1134     unsigned int i;
1135     for (i = 0; i < str->l; i++){
1136         if (str->s[i].unicode() >= 0x7f){
1137             m_allAscii = false;
1138             return m_allAscii;
1139         }
1140     }
1141     
1142     m_allAscii = true;
1143     
1144     return m_allAscii;
1145 }
1146
1147 bool RenderText::shouldUseMonospaceCache(const Font *f) const
1148 {
1149     return (f && f->isFixedPitch() && allAscii() && !style()->htmlFont().isSmallCaps());
1150 }
1151
1152 // We cache the width of the ' ' character for <pre> text.  We could go further
1153 // and cache a widths array for all styles, at the expense of increasing the size of the
1154 // RenderText.
1155 void RenderText::cacheWidths()
1156 {
1157     const Font *f = htmlFont( false );
1158     
1159     if (shouldUseMonospaceCache(f)){
1160         float fw;
1161         QChar c(' ');
1162         f->floatCharacterWidths( &c, 1, 0, 1, 0, 0, 0, &fw);
1163         m_monospaceCharacterWidth = (int)fw;
1164     }
1165     else
1166         m_monospaceCharacterWidth = 0;
1167 }
1168
1169
1170 inline int RenderText::widthFromCache(const Font *f, int start, int len, int tabWidth, int xpos) const
1171 {
1172     if (m_monospaceCharacterWidth != 0){
1173         int i, w = 0;
1174         for (i = start; i < start+len; i++){
1175             QChar c = str->s[i];
1176             int dir = c.direction();
1177             if (dir != QChar::DirNSM && dir != QChar::DirBN) {
1178                 if (c == '\t' && tabWidth != 0) {
1179                     w += tabWidth - ((xpos + w) % tabWidth);
1180                 } else
1181                     w += m_monospaceCharacterWidth;
1182             }
1183         }
1184
1185         return w;
1186     }
1187     
1188     return f->width(str->s, str->l, start, len, tabWidth, xpos);
1189 }
1190
1191 #ifdef XXX
1192 inline int RenderText::widthFromCache(const Font *f, int start, int len) const
1193 {
1194     if (m_monospaceCharacterWidth != 0){
1195         return len * m_monospaceCharacterWidth;
1196     }
1197
1198     return f->width(str->s, str->l, start, len);
1199 }
1200 #endif
1201
1202 #endif
1203
1204 void RenderText::trimmedMinMaxWidth(int leadWidth,
1205                                     int& beginMinW, bool& beginWS, 
1206                                     int& endMinW, bool& endWS,
1207                                     bool& hasBreakableChar, bool& hasBreak,
1208                                     int& beginMaxW, int& endMaxW,
1209                                     int& minW, int& maxW, bool& stripFrontSpaces)
1210 {
1211     bool isPre = style()->whiteSpace() == PRE;
1212     if (isPre)
1213         stripFrontSpaces = false;
1214     
1215     int len = str->l;
1216     if (len == 0 || (stripFrontSpaces && str->containsOnlyWhitespace())) {
1217         maxW = 0;
1218         hasBreak = false;
1219         return;
1220     }
1221     
1222     // if the text has a variable width tab, we need to call 
1223     if (m_hasTab)
1224         calcMinMaxWidth(leadWidth);
1225     
1226     minW = m_minWidth;
1227     maxW = m_maxWidth;
1228     beginWS = stripFrontSpaces ? false : m_hasBeginWS;
1229     endWS = m_hasEndWS;
1230     
1231     beginMinW = m_beginMinWidth;
1232     endMinW = m_endMinWidth;
1233     
1234     hasBreakableChar = m_hasBreakableChar;
1235     hasBreak = m_hasBreak;
1236
1237     if (stripFrontSpaces && (str->s[0] == ' ' || (!isPre && (str->s[0] == '\n' || str->s[0] == '\t')))) {
1238         const Font *f = htmlFont( false );
1239         QChar space[1]; space[0] = ' ';
1240         int spaceWidth = f->width(space, 1, 0, 0);
1241         maxW -= spaceWidth;
1242     }
1243     
1244     stripFrontSpaces = !isPre && m_hasEndWS;
1245     
1246     if (style()->whiteSpace() == NOWRAP)
1247         minW = maxW;
1248     else if (minW > maxW)
1249         minW = maxW;
1250         
1251     // Compute our max widths by scanning the string for newlines.
1252     if (hasBreak) {
1253         const Font *f = htmlFont( false );
1254         bool firstLine = true;
1255         beginMaxW = endMaxW = maxW;
1256         for (int i = 0; i < len; i++)
1257         {
1258             int linelen = 0;
1259             while (i+linelen < len && str->s[i+linelen] != '\n')
1260                 linelen++;
1261                 
1262             if (linelen)
1263             {
1264 #if !APPLE_CHANGES
1265                 endMaxW = f->width(str->s, str->l, i, linelen, tabWidth(), leadWidth + endMaxW); 
1266 #else
1267                 endMaxW = widthFromCache(f, i, linelen, tabWidth(), leadWidth + endMaxW);
1268 #endif
1269                 if (firstLine) {
1270                     firstLine = false;
1271                     leadWidth = 0;
1272                     beginMaxW = endMaxW;
1273                 }
1274                 i += linelen;
1275             }
1276             else if (firstLine) {
1277                 beginMaxW = 0;
1278                 firstLine = false;
1279                 leadWidth = 0;
1280             }
1281     
1282             if (i == len-1)
1283                 // A <pre> run that ends with a newline, as in, e.g.,
1284                 // <pre>Some text\n\n<span>More text</pre>
1285                 endMaxW = 0;
1286         }
1287     }
1288 }
1289
1290 void RenderText::calcMinMaxWidth()
1291 {
1292     // Use 0 for the leadWidth.   If the text contains a variable width tab, the real width
1293     // will get measured when trimmedMinMaxWidth calls again with the real leadWidth.
1294     KHTMLAssert( !minMaxKnown() );
1295     calcMinMaxWidth(0);
1296 }
1297
1298 void RenderText::calcMinMaxWidth(int leadWidth)
1299 {
1300     // ### calc Min and Max width...
1301     m_minWidth = m_beginMinWidth = m_endMinWidth = 0;
1302     m_maxWidth = 0;
1303
1304     if (isBR())
1305         return;
1306         
1307     int currMinWidth = 0;
1308     int currMaxWidth = 0;
1309     m_hasBreakableChar = m_hasBreak = m_hasTab = m_hasBeginWS = m_hasEndWS = false;
1310     
1311     // ### not 100% correct for first-line
1312     const Font *f = htmlFont( false );
1313     int wordSpacing = style()->wordSpacing();
1314     int len = str->l;
1315     bool ignoringSpaces = false;
1316     bool isSpace = false;
1317     bool isPre = style()->whiteSpace() == PRE;
1318     bool firstWord = true;
1319     bool firstLine = true;
1320     for(int i = 0; i < len; i++)
1321     {
1322         const QChar c = str->s[i];
1323         
1324         bool previousCharacterIsSpace = isSpace;
1325         
1326         bool isNewline = false;
1327         if (c == '\n') {
1328             if (isPre) {
1329                 m_hasBreak = true;
1330                 isNewline = true;
1331                 isSpace = false;
1332             } else
1333                 isSpace = true;
1334         } else if (c == '\t') {
1335             if (isPre) {
1336                 m_hasTab = true;
1337                 isSpace = false;
1338             } else
1339                 isSpace = true;
1340         } else {
1341             isSpace = c == ' ';
1342         }
1343         
1344         if ((isSpace || isNewline) && i == 0)
1345             m_hasBeginWS = true;
1346         if ((isSpace || isNewline) && i == len-1)
1347             m_hasEndWS = true;
1348             
1349         if (!ignoringSpaces && !isPre && previousCharacterIsSpace && isSpace)
1350             ignoringSpaces = true;
1351         
1352         if (ignoringSpaces && !isSpace)
1353             ignoringSpaces = false;
1354         
1355         // Ignore spaces and soft hyphens
1356         if (ignoringSpaces || (i > 0 && c.unicode() == SOFT_HYPHEN)) {
1357             continue;
1358         }
1359         
1360         int wordlen = 0;
1361         while (i+wordlen < len && str->s[i+wordlen] != '\n' && str->s[i+wordlen] != ' ' && str->s[i+wordlen] != '\t' &&
1362                (i+wordlen == 0 || str->s[i+wordlen].unicode() != SOFT_HYPHEN) && // Skip soft hyphens
1363                (wordlen == 0 || !isBreakable( str->s, i+wordlen, str->l)))
1364             wordlen++;
1365             
1366         if (wordlen)
1367         {
1368 #if !APPLE_CHANGES
1369             int w = f->width(str->s, str->l, i, wordlen, tabWidth(), leadWidth + currMaxWidth);
1370 #else
1371             int w = widthFromCache(f, i, wordlen, tabWidth(), leadWidth + currMaxWidth);
1372 #endif
1373             currMinWidth += w;
1374             currMaxWidth += w;
1375             
1376             bool isBreakableCharSpace = (i+wordlen < len) ? ((!isPre && (str->s[i+wordlen] == '\n' || str->s[i+wordlen] == '\t')) || 
1377                                                              str->s[i+wordlen] == ' ') : false;
1378
1379             if (i+wordlen < len && style()->whiteSpace() == NORMAL)
1380                 m_hasBreakableChar = true;
1381             
1382             // Add in wordSpacing to our currMaxWidth, but not if this is the last word on a line or the
1383             // last word in the run.
1384             if (wordSpacing && isBreakableCharSpace && !containsOnlyWhitespace(i+wordlen, len-(i+wordlen)))
1385                 currMaxWidth += wordSpacing;
1386
1387             if (firstWord) {
1388                 firstWord = false;
1389                 // If the first character in the run is breakable, then we consider ourselves to have a beginning
1390                 // minimum width of 0, since a break could occur right before our run starts, preventing us from ever
1391                 // being appended to a previous text run when considering the total minimum width of the containing block.
1392                 bool hasBreak = isBreakable(str->s, i, str->l);
1393                 if (hasBreak)
1394                     m_hasBreakableChar = true;
1395                 m_beginMinWidth = hasBreak ? 0 : w;
1396             }
1397             m_endMinWidth = w;
1398             
1399             if (currMinWidth > m_minWidth) m_minWidth = currMinWidth;
1400             currMinWidth = 0;
1401             
1402             i += wordlen-1;
1403         }
1404         else {
1405             // Nowrap can never be broken, so don't bother setting the
1406             // breakable character boolean. Pre can only be broken if we encounter a newline.     
1407             if (style()->whiteSpace() == NORMAL || isNewline)
1408                 m_hasBreakableChar = true;
1409
1410             if (currMinWidth > m_minWidth) m_minWidth = currMinWidth;
1411             currMinWidth = 0;
1412             
1413             if (isNewline) // Only set if isPre was true and we saw a newline.
1414             {
1415                 if (firstLine) {
1416                     firstLine = false;
1417                     leadWidth = 0;
1418                     m_beginMinWidth = currMaxWidth;
1419                 }
1420                 
1421                 if (currMaxWidth > m_maxWidth) m_maxWidth = currMaxWidth;
1422                 currMaxWidth = 0;
1423             }
1424             else
1425             {
1426                 currMaxWidth += f->width(str->s, str->l, i + wordlen, 1, tabWidth(), leadWidth + currMaxWidth);
1427             }
1428         }
1429     }
1430
1431     if(currMinWidth > m_minWidth) m_minWidth = currMinWidth;
1432     if(currMaxWidth > m_maxWidth) m_maxWidth = currMaxWidth;
1433         
1434     if (style()->whiteSpace() != NORMAL)
1435         m_minWidth = m_maxWidth;
1436
1437     if (isPre) {
1438         if (firstLine)
1439             m_beginMinWidth = m_maxWidth;
1440         m_endMinWidth = currMaxWidth;
1441     }
1442     
1443     setMinMaxKnown();
1444     //kdDebug( 6040 ) << "Text::calcMinMaxWidth(): min = " << m_minWidth << " max = " << m_maxWidth << endl;
1445 }
1446
1447 bool RenderText::containsOnlyWhitespace(unsigned int from, unsigned int len) const
1448 {
1449     unsigned int currPos;
1450     for (currPos = from; 
1451          currPos < from+len && (str->s[currPos] == '\n' || str->s[currPos].unicode() == ' ' || str->s[currPos] == '\t'); 
1452          currPos++);
1453     return currPos >= (from+len);
1454 }
1455
1456 int RenderText::minXPos() const
1457 {
1458     if (!m_firstTextBox) return 0;
1459     int retval=6666666;
1460     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
1461         retval = kMin(retval, (int)box->m_x);
1462     return retval;
1463 }
1464
1465 int RenderText::xPos() const
1466 {
1467     return m_firstTextBox ? m_firstTextBox->m_x : 0;
1468 }
1469
1470 int RenderText::yPos() const
1471 {
1472     return m_firstTextBox ? m_firstTextBox->m_y : 0;
1473 }
1474
1475 const QFont &RenderText::font()
1476 {
1477     return style()->font();
1478 }
1479
1480 void RenderText::setSelectionState(SelectionState s)
1481 {
1482     InlineTextBox* box;
1483     
1484     m_selectionState = s;
1485     if (s == SelectionStart || s == SelectionEnd || s == SelectionBoth) {
1486         int startPos, endPos;
1487         selectionStartEnd(startPos, endPos);
1488         if(selectionState() == SelectionStart) {
1489             endPos = str->l;
1490             
1491             // to handle selection from end of text to end of line
1492             if (startPos != 0 && startPos == endPos) {
1493                 startPos = endPos - 1;
1494             }
1495         } else if(selectionState() == SelectionEnd)
1496             startPos = 0;
1497         
1498         for (box = firstTextBox(); box; box = box->nextTextBox()) {
1499             if (box->isSelected(startPos, endPos)) {
1500                 RootInlineBox* line = box->root();
1501                 if (line)
1502                     line->setHasSelectedChildren(true);
1503             }
1504         }
1505     }
1506     else {
1507         for (box = firstTextBox(); box; box = box->nextTextBox()) {
1508             RootInlineBox* line = box->root();
1509             if (line)
1510                 line->setHasSelectedChildren(s == SelectionInside);
1511         }
1512     }
1513     
1514     containingBlock()->setSelectionState(s);
1515 }
1516
1517 void RenderText::setTextWithOffset(DOMStringImpl *text, uint offset, uint len, bool force)
1518 {
1519     uint oldLen = str ? str->l : 0;
1520     uint newLen = text ? text->l : 0;
1521     int delta = newLen - oldLen;
1522     uint end = len ? offset+len-1 : offset;
1523
1524     RootInlineBox* firstRootBox = 0;
1525     RootInlineBox* lastRootBox = 0;
1526     
1527     bool dirtiedLines = false;
1528     
1529     // Dirty all text boxes that include characters in between offset and offset+len.
1530     for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
1531         // Text run is entirely before the affected range.
1532         if (curr->end() < offset)
1533             continue;
1534         
1535         // Text run is entirely after the affected range.
1536         if (curr->start() > end) {
1537             curr->offsetRun(delta);
1538             RootInlineBox* root = curr->root();
1539             if (!firstRootBox) {
1540                 firstRootBox = root;
1541                 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.
1542                     firstRootBox->markDirty();
1543                     dirtiedLines = true;
1544                 }
1545             }
1546             lastRootBox = root;
1547         }
1548         else if (curr->end() >= offset && curr->end() <= end) {
1549             curr->dirtyLineBoxes(); // Text run overlaps with the left end of the affected range.
1550             dirtiedLines = true;
1551         }
1552         else if (curr->start() <= offset && curr->end() >= end) {
1553             curr->dirtyLineBoxes(); // Text run subsumes the affected range.
1554             dirtiedLines = true;
1555         }
1556         else if (curr->start() <= end && curr->end() >= end) {
1557             curr->dirtyLineBoxes(); // Text run overlaps with right end of the affected range.
1558             dirtiedLines = true;
1559         }
1560     }
1561     
1562     // Now we have to walk all of the clean lines and adjust their cached line break information
1563     // to reflect our updated offsets.
1564     if (lastRootBox)
1565         lastRootBox = lastRootBox->nextRootBox();
1566     if (firstRootBox) {
1567         RootInlineBox* prev = firstRootBox->prevRootBox();
1568         if (prev)
1569             firstRootBox = prev;
1570     }
1571     for (RootInlineBox* curr = firstRootBox; curr && curr != lastRootBox; curr = curr->nextRootBox()) {
1572         if (curr->lineBreakObj() == this && curr->lineBreakPos() > end)
1573             curr->setLineBreakPos(curr->lineBreakPos()+delta);
1574     }
1575     
1576     m_linesDirty = dirtiedLines;
1577     setText(text, force);
1578 }
1579
1580 void RenderText::setText(DOMStringImpl *text, bool force)
1581 {
1582     if (!text)
1583         return;
1584     if (!force && str == text)
1585         return;
1586     if (str)
1587         str->deref();
1588
1589 #ifdef APPLE_CHANGES
1590     m_allAsciiChecked = false;
1591 #endif
1592
1593     str = text;
1594     if (str) {
1595         str = str->replace('\\', backslashAsCurrencySymbol());
1596         if ( style() ) {
1597             switch(style()->textTransform()) {
1598                 case CAPITALIZE:   str = str->capitalize();  break;
1599                 case UPPERCASE:   str = str->upper();       break;
1600                 case LOWERCASE:  str = str->lower();       break;
1601                 case NONE:
1602                 default:;
1603             }
1604         }
1605         str->ref();
1606     }
1607
1608 #if APPLE_CHANGES
1609     cacheWidths();
1610 #endif
1611
1612     // ### what should happen if we change the text of a
1613     // RenderBR object ?
1614     KHTMLAssert(!isBR() || (str->l == 1 && (*str->s) == '\n'));
1615     KHTMLAssert(!str->l || str->s);
1616
1617     setNeedsLayoutAndMinMaxRecalc();
1618     
1619 #ifdef BIDI_DEBUG
1620     QConstString cstr(str->s, str->l);
1621     kdDebug( 6040 ) << "RenderText::setText( " << cstr.string().length() << " ) '" << cstr.string() << "'" << endl;
1622 #endif
1623 }
1624
1625 int RenderText::height() const
1626 {
1627     // FIXME: Why use line-height? Shouldn't we be adding in the height of the last text box? -dwh
1628     int retval = 0;
1629     if (firstTextBox())
1630         retval = lastTextBox()->m_y + lineHeight(false) - firstTextBox()->m_y;
1631     return retval;
1632 }
1633
1634 short RenderText::lineHeight(bool firstLine, bool) const
1635 {
1636     // Always use the interior line height of the parent (e.g., if our parent is an inline block).
1637     return parent()->lineHeight(firstLine, true);
1638 }
1639
1640 short RenderText::baselinePosition( bool firstLine, bool ) const
1641 {
1642     const QFontMetrics &fm = metrics( firstLine );
1643     return fm.ascent() +
1644         ( lineHeight( firstLine ) - fm.height() ) / 2;
1645 }
1646
1647 void RenderText::dirtyLineBoxes(bool fullLayout, bool)
1648 {
1649     if (fullLayout)
1650         deleteTextBoxes();
1651     else if (!m_linesDirty) {
1652         for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
1653             box->dirtyLineBoxes();
1654     }
1655     m_linesDirty = false;
1656 }
1657
1658 InlineBox* RenderText::createInlineBox(bool, bool isRootLineBox, bool)
1659 {
1660     KHTMLAssert(!isRootLineBox);
1661     InlineTextBox* textBox = new (renderArena()) InlineTextBox(this);
1662     if (!m_firstTextBox)
1663         m_firstTextBox = m_lastTextBox = textBox;
1664     else {
1665         m_lastTextBox->setNextLineBox(textBox);
1666         textBox->setPreviousLineBox(m_lastTextBox);
1667         m_lastTextBox = textBox;
1668     }
1669     return textBox;
1670 }
1671
1672 void RenderText::position(InlineBox* box, int from, int len, bool reverse)
1673 {
1674     InlineTextBox *s = static_cast<InlineTextBox*>(box);
1675     
1676     // ### should not be needed!!!
1677     if (len == 0) {
1678         // We want the box to be destroyed.
1679         s->remove();
1680         s->detach(renderArena());
1681         m_firstTextBox = m_lastTextBox = 0;
1682         return;
1683     }
1684     
1685     reverse = reverse && !style()->visuallyOrdered();
1686
1687 #ifdef DEBUG_LAYOUT
1688     QChar *ch = str->s+from;
1689     QConstString cstr(ch, len);
1690     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;
1691 #endif
1692
1693     s->m_reversed = reverse;
1694     s->m_start = from;
1695     s->m_len = len;
1696 }
1697
1698 unsigned int RenderText::width(unsigned int from, unsigned int len, int xpos, bool firstLine) const
1699 {
1700     if(!str->s || from > str->l ) return 0;
1701     if ( from + len > str->l ) len = str->l - from;
1702
1703     const Font *f = htmlFont( firstLine );
1704     return width( from, len, f, xpos );
1705 }
1706
1707 unsigned int RenderText::width(unsigned int from, unsigned int len, const Font *f, int xpos) const
1708 {
1709     if(!str->s || from > str->l ) return 0;
1710     if ( from + len > str->l ) len = str->l - from;
1711
1712     int w;
1713     if ( style()->whiteSpace() != PRE && f == &style()->htmlFont() && from == 0 && len == str->l ) {
1714         w = m_maxWidth;
1715 #if APPLE_CHANGES
1716     } else if (f == &style()->htmlFont()) {
1717         w = widthFromCache (f, from, len, tabWidth(), xpos);
1718 #endif
1719     } else {
1720         w = f->width(str->s, str->l, from, len, tabWidth(), xpos );
1721     }
1722         
1723     //kdDebug( 6040 ) << "RenderText::width(" << from << ", " << len << ") = " << w << endl;
1724     return w;
1725 }
1726
1727 int RenderText::width() const
1728 {
1729     int minx = 100000000;
1730     int maxx = 0;
1731     // slooow
1732     for (InlineTextBox* s = firstTextBox(); s; s = s->nextTextBox()) {
1733         if(s->m_x < minx)
1734             minx = s->m_x;
1735         if(s->m_x + s->m_width > maxx)
1736             maxx = s->m_x + s->m_width;
1737     }
1738
1739     return kMax(0, maxx-minx);
1740 }
1741
1742 QRect RenderText::getAbsoluteRepaintRect()
1743 {
1744     RenderObject *cb = containingBlock();
1745     return cb->getAbsoluteRepaintRect();
1746 }
1747
1748 QRect RenderText::selectionRect()
1749 {
1750     QRect rect;
1751     if (selectionState() == SelectionNone)
1752         return rect;
1753     RenderBlock* cb =  containingBlock();
1754     if (!cb)
1755         return rect;
1756     
1757     // Now calculate startPos and endPos for painting selection.
1758     // We include a selection while endPos > 0
1759     int startPos, endPos;
1760     if (selectionState() == SelectionInside) {
1761         // We are fully selected.
1762         startPos = 0;
1763         endPos = str->l;
1764     } else {
1765         selectionStartEnd(startPos, endPos);
1766         if (selectionState() == SelectionStart)
1767             endPos = str->l;
1768         else if (selectionState() == SelectionEnd)
1769             startPos = 0;
1770     }
1771     
1772     if (startPos == endPos)
1773         return rect;
1774
1775     int absx, absy;
1776     cb->absolutePosition(absx, absy);
1777     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
1778         QRect r = box->selectionRect(absx, absy, startPos, endPos);
1779         if (!r.isEmpty()) {
1780             if (rect.isEmpty())
1781                 rect = r;
1782             else
1783                 rect = rect.unite(r);
1784         }
1785     }
1786
1787     return rect;
1788 }
1789
1790 short RenderText::verticalPositionHint( bool firstLine ) const
1791 {
1792     return parent()->verticalPositionHint( firstLine );
1793 }
1794
1795 const QFontMetrics &RenderText::metrics(bool firstLine) const
1796 {
1797     return style(firstLine)->fontMetrics();
1798 }
1799
1800 const Font *RenderText::htmlFont(bool firstLine) const
1801 {
1802     return &style(firstLine)->htmlFont();
1803 }
1804
1805 long RenderText::caretMinOffset() const
1806 {
1807     InlineTextBox *box = firstTextBox();
1808     if (!box)
1809         return 0;
1810     int minOffset = box->m_start;
1811     for (box = box->nextTextBox(); box; box = box->nextTextBox())
1812         minOffset = kMin(minOffset, box->m_start);
1813     return minOffset;
1814 }
1815
1816 long RenderText::caretMaxOffset() const
1817 {
1818     InlineTextBox* box = lastTextBox();
1819     if (!box) 
1820         return str->l;
1821     int maxOffset = box->m_start + box->m_len;
1822     for (box = box->prevTextBox(); box; box = box->prevTextBox())
1823         maxOffset = kMax(maxOffset,box->m_start + box->m_len);
1824     return maxOffset;
1825 }
1826
1827 unsigned long RenderText::caretMaxRenderedOffset() const
1828 {
1829     int l = 0;
1830     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
1831         l += box->m_len;
1832     return l;
1833 }
1834
1835 InlineBox *RenderText::inlineBox(long offset, EAffinity affinity)
1836 {
1837     for (InlineTextBox *box = firstTextBox(); box; box = box->nextTextBox()) {
1838         if (offset >= box->m_start && offset <= box->m_start + box->m_len) {
1839             if (affinity == DOWNSTREAM && box->nextTextBox() && offset == box->m_start + box->m_len)
1840                 return box->nextTextBox();
1841             return box;
1842         }
1843         else if (offset < box->m_start) {
1844             // The offset we're looking for is before this node
1845             // this means the offset must be in content that is
1846             // not rendered.
1847             return box->prevTextBox() ? box->prevTextBox() : firstTextBox();
1848         }
1849     }
1850     
1851     return 0;
1852 }
1853
1854 RenderTextFragment::RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str,
1855                                        int startOffset, int endOffset)
1856 :RenderText(_node, _str->substring(startOffset, endOffset)), 
1857 m_start(startOffset), m_end(endOffset), m_generatedContentStr(0)
1858 {}
1859
1860 RenderTextFragment::RenderTextFragment(DOM::NodeImpl* _node, DOM::DOMStringImpl* _str)
1861 :RenderText(_node, _str), m_start(0)
1862 {
1863     m_generatedContentStr = _str;
1864     if (_str) {
1865         _str->ref();
1866         m_end = _str->l;
1867     }
1868     else
1869         m_end = 0;
1870 }
1871     
1872 RenderTextFragment::~RenderTextFragment()
1873 {
1874     if (m_generatedContentStr)
1875         m_generatedContentStr->deref();
1876 }
1877
1878 bool RenderTextFragment::isTextFragment() const
1879 {
1880     return true;
1881 }
1882
1883 DOM::DOMStringImpl* RenderTextFragment::originalString() const
1884 {
1885     DOM::DOMStringImpl* result = 0;
1886     if (element())
1887         result = element()->string();
1888     else
1889         result = contentString();
1890     if (result && (start() > 0 || start() < result->l))
1891         result = result->substring(start(), end());
1892     return result;
1893 }
1894 #undef BIDI_DEBUG
1895 #undef DEBUG_LAYOUT