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