Remove drawLineForText from the Font API. Implement it natively in
[WebKit-https.git] / WebCore / rendering / render_line.cpp
1 /**
2 * This file is part of the html renderer for KDE.
3  *
4  * Copyright (C) 2003, 2006 Apple Computer, Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21 // -------------------------------------------------------------------------
22
23 #include "config.h"
24 #include "render_line.h"
25
26 #include "CachedImage.h"
27 #include "Document.h"
28 #include "GraphicsContext.h"
29 #include "InlineTextBox.h"
30 #include "RenderBlock.h"
31 #include "RenderTableCell.h"
32 #include "RenderArena.h"
33 #include "RenderInline.h"
34 #include "render_list.h"
35 #include <assert.h>
36
37 using namespace std;
38
39 namespace WebCore {
40     
41 #ifndef NDEBUG
42 static bool inInlineBoxDetach;
43 #endif
44
45 class EllipsisBox : public InlineBox
46 {
47 public:
48     EllipsisBox(RenderObject* obj, const WebCore::AtomicString& ellipsisStr, InlineFlowBox* p,
49                 int w, int y, int h, int b, bool firstLine, InlineBox* markupBox)
50     :InlineBox(obj), m_str(ellipsisStr) {
51         m_parent = p;
52         m_width = w;
53         m_y = y;
54         m_height = h;
55         m_baseline = b;
56         m_firstLine = firstLine;
57         m_constructed = true;
58         m_markupBox = markupBox;
59     }
60     
61     virtual void paint(RenderObject::PaintInfo& i, int _tx, int _ty);
62     virtual bool nodeAtPoint(RenderObject::NodeInfo& info, int _x, int _y, int _tx, int _ty);
63
64 private:
65     WebCore::AtomicString m_str;
66     InlineBox* m_markupBox;
67 };
68
69 void InlineBox::remove()
70
71     if (parent())
72         parent()->removeChild(this);
73 }
74
75 void InlineBox::destroy(RenderArena* renderArena)
76 {
77 #ifndef NDEBUG
78     inInlineBoxDetach = true;
79 #endif
80     delete this;
81 #ifndef NDEBUG
82     inInlineBoxDetach = false;
83 #endif
84
85     // Recover the size left there for us by operator delete and free the memory.
86     renderArena->free(*(size_t *)this, this);
87 }
88
89 void* InlineBox::operator new(size_t sz, RenderArena* renderArena) throw()
90 {
91     return renderArena->allocate(sz);
92 }
93
94
95 void InlineBox::operator delete(void* ptr, size_t sz)
96 {
97     assert(inInlineBoxDetach);
98
99     // Stash size where destroy can find it.
100     *(size_t *)ptr = sz;
101 }
102
103 #ifndef NDEBUG
104 void InlineBox::showTreeForThis() const
105 {
106     if (m_object)
107         m_object->showTreeForThis();
108 }
109 #endif
110
111 int InlineBox::caretMinOffset() const 
112
113     return 0; 
114 }
115
116 int InlineBox::caretMaxOffset() const 
117
118     return 1; 
119 }
120
121 unsigned InlineBox::caretMaxRenderedOffset() const 
122
123     return 1; 
124 }
125
126 void InlineBox::dirtyLineBoxes()
127 {
128     markDirty();
129     for (InlineFlowBox* curr = parent(); curr && !curr->isDirty(); curr = curr->parent())
130         curr->markDirty();
131 }
132
133 void InlineBox::deleteLine(RenderArena* arena)
134 {
135     if (!m_extracted)
136         m_object->setInlineBoxWrapper(0);
137     destroy(arena);
138 }
139
140 void InlineBox::extractLine()
141 {
142     m_extracted = true;
143     m_object->setInlineBoxWrapper(0);
144 }
145
146 void InlineBox::attachLine()
147 {
148     m_extracted = false;
149     m_object->setInlineBoxWrapper(this);
150 }
151
152 void InlineBox::adjustPosition(int dx, int dy)
153 {
154     m_x += dx;
155     m_y += dy;
156     if (m_object->isReplaced() || m_object->isBR())
157         m_object->setPos(m_object->xPos() + dx, m_object->yPos() + dy);
158 }
159
160 void InlineBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
161 {
162     if (!object()->shouldPaintWithinRoot(i) || (i.phase != PaintPhaseForeground && i.phase != PaintPhaseSelection))
163         return;
164
165     // Paint all phases of replaced elements atomically, as though the replaced element established its
166     // own stacking context.  (See Appendix E.2, section 6.4 on inline block/table elements in the CSS2.1
167     // specification.)
168     bool paintSelectionOnly = i.phase == PaintPhaseSelection;
169     RenderObject::PaintInfo info(i);
170     info.phase = paintSelectionOnly ? i.phase : PaintPhaseBlockBackground;
171     object()->paint(info, tx, ty);
172     if (!paintSelectionOnly) {
173         info.phase = PaintPhaseChildBlockBackgrounds;
174         object()->paint(info, tx, ty);
175         info.phase = PaintPhaseFloat;
176         object()->paint(info, tx, ty);
177         info.phase = PaintPhaseForeground;
178         object()->paint(info, tx, ty);
179         info.phase = PaintPhaseOutline;
180         object()->paint(info, tx, ty);
181     }
182 }
183
184 bool InlineBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty)
185 {
186     // Hit test all phases of replaced elements atomically, as though the replaced element established its
187     // own stacking context.  (See Appendix E.2, section 6.4 on inline block/table elements in the CSS2.1
188     // specification.)
189     return object()->hitTest(i, x, y, tx, ty);
190 }
191
192 RootInlineBox* InlineBox::root()
193
194     if (m_parent)
195         return m_parent->root(); 
196     return static_cast<RootInlineBox*>(this);
197 }
198
199 bool InlineBox::nextOnLineExists() const
200 {
201     if (!parent())
202         return false;
203     
204     if (nextOnLine())
205         return true;
206     
207     return parent()->nextOnLineExists();
208 }
209
210 bool InlineBox::prevOnLineExists() const
211 {
212     if (!parent())
213         return false;
214     
215     if (prevOnLine())
216         return true;
217     
218     return parent()->prevOnLineExists();
219 }
220
221 InlineBox* InlineBox::firstLeafChild()
222 {
223     return this;
224 }
225
226 InlineBox* InlineBox::lastLeafChild()
227 {
228     return this;
229 }
230
231 InlineBox* InlineBox::nextLeafChild()
232 {
233     return parent() ? parent()->firstLeafChildAfterBox(this) : 0;
234 }
235
236 InlineBox* InlineBox::prevLeafChild()
237 {
238     return parent() ? parent()->lastLeafChildBeforeBox(this) : 0;
239 }
240
241 RenderObject::SelectionState InlineBox::selectionState()
242 {
243     return object()->selectionState();
244 }
245
246 bool InlineBox::canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth)
247 {
248     // Non-replaced elements can always accommodate an ellipsis.
249     if (!m_object || !m_object->isReplaced())
250         return true;
251     
252     IntRect boxRect(m_x, 0, m_width, 10);
253     IntRect ellipsisRect(ltr ? blockEdge - ellipsisWidth : blockEdge, 0, ellipsisWidth, 10);
254     return !(boxRect.intersects(ellipsisRect));
255 }
256
257 int InlineBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool&)
258 {
259     // Use -1 to mean "we didn't set the position."
260     return -1;
261 }
262
263 RenderFlow* InlineFlowBox::flowObject()
264 {
265     return static_cast<RenderFlow*>(m_object);
266 }
267
268 int InlineFlowBox::marginLeft()
269 {
270     if (!includeLeftEdge())
271         return 0;
272     
273     Length margin = object()->style()->marginLeft();
274     if (margin.isAuto())
275         return 0;
276     if (margin.isFixed())
277         return margin.value();
278     return object()->marginLeft();
279 }
280
281 int InlineFlowBox::marginRight()
282 {
283     if (!includeRightEdge())
284         return 0;
285     
286     Length margin = object()->style()->marginRight();
287     if (margin.isAuto())
288         return 0;
289     if (margin.isFixed())
290         return margin.value();
291     return object()->marginRight();
292 }
293
294 int InlineFlowBox::marginBorderPaddingLeft()
295 {
296     return marginLeft() + borderLeft() + paddingLeft();
297 }
298
299 int InlineFlowBox::marginBorderPaddingRight()
300 {
301     return marginRight() + borderRight() + paddingRight();
302 }
303
304 int InlineFlowBox::getFlowSpacingWidth()
305 {
306     int totWidth = marginBorderPaddingLeft() + marginBorderPaddingRight();
307     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
308         if (curr->isInlineFlowBox())
309             totWidth += static_cast<InlineFlowBox*>(curr)->getFlowSpacingWidth();
310     }
311     return totWidth;
312 }
313
314 void InlineFlowBox::addToLine(InlineBox* child) {
315     if (!m_firstChild)
316         m_firstChild = m_lastChild = child;
317     else {
318         m_lastChild->m_next = child;
319         child->m_prev = m_lastChild;
320         m_lastChild = child;
321     }
322     child->setFirstLineStyleBit(m_firstLine);
323     child->setParent(this);
324     if (child->isText())
325         m_hasTextChildren = true;
326     if (child->object()->selectionState() != RenderObject::SelectionNone)
327         root()->setHasSelectedChildren(true);
328 }
329
330 void InlineFlowBox::removeChild(InlineBox* child)
331 {
332     if (!m_dirty)
333         dirtyLineBoxes();
334
335     root()->childRemoved(child);
336
337     if (child == m_firstChild)
338         m_firstChild = child->nextOnLine();
339     if (child == m_lastChild)
340         m_lastChild = child->prevOnLine();
341     if (child->nextOnLine())
342         child->nextOnLine()->setPrevOnLine(child->prevOnLine());
343     if (child->prevOnLine())
344         child->prevOnLine()->setNextOnLine(child->nextOnLine());
345     
346     child->setParent(0);
347 }
348
349 void InlineFlowBox::deleteLine(RenderArena* arena)
350 {
351     InlineBox* child = m_firstChild;
352     InlineBox* next = 0;
353     while (child) {
354         next = child->nextOnLine();
355         child->deleteLine(arena);
356         child = next;
357     }
358     
359     static_cast<RenderFlow*>(m_object)->removeLineBox(this);
360     destroy(arena);
361 }
362
363 void InlineFlowBox::extractLine()
364 {
365     if (!m_extracted)
366         static_cast<RenderFlow*>(m_object)->extractLineBox(this);
367     for (InlineBox* child = m_firstChild; child; child = child->nextOnLine())
368         child->extractLine();
369 }
370
371 void InlineFlowBox::attachLine()
372 {
373     if (m_extracted)
374         static_cast<RenderFlow*>(m_object)->attachLineBox(this);
375     for (InlineBox* child = m_firstChild; child; child = child->nextOnLine())
376         child->attachLine();
377 }
378
379 void InlineFlowBox::adjustPosition(int dx, int dy)
380 {
381     InlineRunBox::adjustPosition(dx, dy);
382     for (InlineBox* child = m_firstChild; child; child = child->nextOnLine())
383         child->adjustPosition(dx, dy);
384 }
385
386 bool InlineFlowBox::onEndChain(RenderObject* endObject)
387 {
388     if (!endObject)
389         return false;
390     
391     if (endObject == object())
392         return true;
393
394     RenderObject* curr = endObject;
395     RenderObject* parent = curr->parent();
396     while (parent && !parent->isRenderBlock()) {
397         if (parent->lastChild() != curr || parent == object())
398             return false;
399             
400         curr = parent;
401         parent = curr->parent();
402     }
403
404     return true;
405 }
406
407 void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, RenderObject* endObject)
408 {
409     // All boxes start off open.  They will not apply any margins/border/padding on
410     // any side.
411     bool includeLeftEdge = false;
412     bool includeRightEdge = false;
413
414     RenderFlow* flow = static_cast<RenderFlow*>(object());
415     
416     if (!flow->firstChild())
417         includeLeftEdge = includeRightEdge = true; // Empty inlines never split across lines.
418     else if (parent()) { // The root inline box never has borders/margins/padding.
419         bool ltr = flow->style()->direction() == LTR;
420         
421         // Check to see if all initial lines are unconstructed.  If so, then
422         // we know the inline began on this line.
423         if (!flow->firstLineBox()->isConstructed()) {
424             if (ltr && flow->firstLineBox() == this)
425                 includeLeftEdge = true;
426             else if (!ltr && flow->lastLineBox() == this)
427                 includeRightEdge = true;
428         }
429     
430         // In order to determine if the inline ends on this line, we check three things:
431         // (1) If we are the last line and we don't have a continuation(), then we can
432         // close up.
433         // (2) If the last line box for the flow has an object following it on the line (ltr,
434         // reverse for rtl), then the inline has closed.
435         // (3) The line may end on the inline.  If we are the last child (climbing up
436         // the end object's chain), then we just closed as well.
437         if (!flow->lastLineBox()->isConstructed()) {
438             if (ltr) {
439                 if (!nextLineBox() &&
440                     ((lastLine && !object()->continuation()) || nextOnLineExists()
441                      || onEndChain(endObject)))
442                     includeRightEdge = true;
443             }
444             else {
445                 if ((!prevLineBox() || !prevLineBox()->isConstructed()) &&
446                     ((lastLine && !object()->continuation()) ||
447                      prevOnLineExists() || onEndChain(endObject)))
448                     includeLeftEdge = true;
449             }
450         }
451     }
452
453     setEdges(includeLeftEdge, includeRightEdge);
454
455     // Recur into our children.
456     for (InlineBox* currChild = firstChild(); currChild; currChild = currChild->nextOnLine()) {
457         if (currChild->isInlineFlowBox()) {
458             InlineFlowBox* currFlow = static_cast<InlineFlowBox*>(currChild);
459             currFlow->determineSpacingForFlowBoxes(lastLine, endObject);
460         }
461     }
462 }
463
464 int InlineFlowBox::placeBoxesHorizontally(int x, int& leftPosition, int& rightPosition, bool & needsWordSpacing)
465 {
466     // Set our x position.
467     setXPos(x);
468     leftPosition = min(x, leftPosition);
469
470     int startX = x;
471     x += borderLeft() + paddingLeft();
472     
473     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
474         if (curr->object()->isText()) {
475             InlineTextBox *text = static_cast<InlineTextBox*>(curr);
476             RenderText *rt = static_cast<RenderText*>(text->object());
477             if (rt->length()) {
478                 if (needsWordSpacing && QChar(rt->text()[text->start()]).isSpace())
479                     x += rt->font(m_firstLine)->wordSpacing();
480                 needsWordSpacing = !QChar(rt->text()[text->end()]).isSpace();
481             }
482             text->setXPos(x);
483             int shadowLeft = 0;
484             int shadowRight = 0;
485             for (ShadowData* shadow = rt->style()->textShadow(); shadow; shadow = shadow->next) {
486                 shadowLeft = min(shadowLeft, shadow->x - shadow->blur);
487                 shadowRight = max(shadowRight, shadow->x + shadow->blur);
488             }
489             leftPosition = min(x + shadowLeft, leftPosition);
490             rightPosition = max(x + text->width() + shadowRight, rightPosition);
491             m_maxHorizontalShadow = max(max(shadowRight, -shadowLeft), m_maxHorizontalShadow);
492             x += text->width();
493         } else {
494             if (curr->object()->isPositioned()) {
495                 if (curr->object()->parent()->style()->direction() == LTR)
496                     curr->setXPos(x);
497                 else
498                     // Our offset that we cache needs to be from the edge of the right border box and
499                     // not the left border box.  We have to subtract |x| from the width of the block
500                     // (which can be obtained from the root line box).
501                     curr->setXPos(root()->object()->width()-x);
502                 continue; // The positioned object has no effect on the width.
503             }
504             if (curr->object()->isInlineFlow()) {
505                 InlineFlowBox* flow = static_cast<InlineFlowBox*>(curr);
506                 if (curr->object()->isCompact()) {
507                     int ignoredX = x;
508                     flow->placeBoxesHorizontally(ignoredX, leftPosition, rightPosition, needsWordSpacing);
509                 } else {
510                     x += flow->marginLeft();
511                     x = flow->placeBoxesHorizontally(x, leftPosition, rightPosition, needsWordSpacing);
512                     x += flow->marginRight();
513                 }
514             } else if (!curr->object()->isCompact() && (!curr->object()->isListMarker() || static_cast<RenderListMarker*>(curr->object())->isInside())) {
515                 x += curr->object()->marginLeft();
516                 curr->setXPos(x);
517                 leftPosition = min(x, leftPosition);
518                 rightPosition = max(x + curr->width(), rightPosition);
519                 x += curr->width() + curr->object()->marginRight();
520             }
521         }
522     }
523
524     x += borderRight() + paddingRight();
525     setWidth(x-startX);
526     rightPosition = max(xPos() + width(), rightPosition);
527
528     return x;
529 }
530
531 void InlineFlowBox::verticallyAlignBoxes(int& heightOfBlock)
532 {
533     int maxPositionTop = 0;
534     int maxPositionBottom = 0;
535     int maxAscent = 0;
536     int maxDescent = 0;
537
538     // Figure out if we're in strict mode.  Note that we can't simply use !style()->htmlHacks(),
539     // because that would match almost strict mode as well.
540     RenderObject* curr = object();
541     while (curr && !curr->element())
542         curr = curr->container();
543     bool strictMode = (curr && curr->document()->inStrictMode());
544     
545     computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);
546
547     if (maxAscent + maxDescent < max(maxPositionTop, maxPositionBottom))
548         adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
549
550     int maxHeight = maxAscent + maxDescent;
551     int topPosition = heightOfBlock;
552     int bottomPosition = heightOfBlock;
553     int selectionTop = heightOfBlock;
554     int selectionBottom = heightOfBlock;
555     placeBoxesVertically(heightOfBlock, maxHeight, maxAscent, strictMode, topPosition, bottomPosition, selectionTop, selectionBottom);
556
557     setVerticalOverflowPositions(topPosition, bottomPosition);
558     setVerticalSelectionPositions(selectionTop, selectionBottom);
559
560     // Shrink boxes with no text children in quirks and almost strict mode.
561     if (!strictMode)
562         shrinkBoxesWithNoTextChildren(topPosition, bottomPosition);
563     
564     heightOfBlock += maxHeight;
565 }
566
567 void InlineFlowBox::adjustMaxAscentAndDescent(int& maxAscent, int& maxDescent,
568                                               int maxPositionTop, int maxPositionBottom)
569 {
570     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
571         // The computed lineheight needs to be extended for the
572         // positioned elements
573         if (curr->object()->isPositioned())
574             continue; // Positioned placeholders don't affect calculations.
575         if (curr->yPos() == PositionTop || curr->yPos() == PositionBottom) {
576             if (curr->yPos() == PositionTop) {
577                 if (maxAscent + maxDescent < curr->height())
578                     maxDescent = curr->height() - maxAscent;
579             }
580             else {
581                 if (maxAscent + maxDescent < curr->height())
582                     maxAscent = curr->height() - maxDescent;
583             }
584
585             if (maxAscent + maxDescent >= max(maxPositionTop, maxPositionBottom))
586                 break;
587         }
588
589         if (curr->isInlineFlowBox())
590             static_cast<InlineFlowBox*>(curr)->adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
591     }
592 }
593
594 void InlineFlowBox::computeLogicalBoxHeights(int& maxPositionTop, int& maxPositionBottom,
595                                              int& maxAscent, int& maxDescent, bool strictMode)
596 {
597     if (isRootInlineBox()) {
598         // Examine our root box.
599         setHeight(object()->lineHeight(m_firstLine, true));
600         bool isTableCell = object()->isTableCell();
601         if (isTableCell) {
602             RenderTableCell* tableCell = static_cast<RenderTableCell*>(object());
603             setBaseline(tableCell->RenderBlock::baselinePosition(m_firstLine, true));
604         }
605         else
606             setBaseline(object()->baselinePosition(m_firstLine, true));
607         if (hasTextChildren() || strictMode) {
608             int ascent = baseline();
609             int descent = height() - ascent;
610             if (maxAscent < ascent)
611                 maxAscent = ascent;
612             if (maxDescent < descent)
613                 maxDescent = descent;
614         }
615     }
616     
617     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
618         if (curr->object()->isPositioned())
619             continue; // Positioned placeholders don't affect calculations.
620         
621         curr->setHeight(curr->object()->lineHeight(m_firstLine));
622         curr->setBaseline(curr->object()->baselinePosition(m_firstLine));
623         curr->setYPos(curr->object()->verticalPositionHint(m_firstLine));
624         if (curr->yPos() == PositionTop) {
625             if (maxPositionTop < curr->height())
626                 maxPositionTop = curr->height();
627         }
628         else if (curr->yPos() == PositionBottom) {
629             if (maxPositionBottom < curr->height())
630                 maxPositionBottom = curr->height();
631         }
632         else if (curr->hasTextChildren() || strictMode) {
633             int ascent = curr->baseline() - curr->yPos();
634             int descent = curr->height() - ascent;
635             if (maxAscent < ascent)
636                 maxAscent = ascent;
637             if (maxDescent < descent)
638                 maxDescent = descent;
639         }
640
641         if (curr->isInlineFlowBox())
642             static_cast<InlineFlowBox*>(curr)->computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);
643     }
644 }
645
646 void InlineFlowBox::placeBoxesVertically(int y, int maxHeight, int maxAscent, bool strictMode,
647                                          int& topPosition, int& bottomPosition, int& selectionTop, int& selectionBottom)
648 {
649     if (isRootInlineBox())
650         setYPos(y + maxAscent - baseline());// Place our root box.
651     
652     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
653         if (curr->object()->isPositioned())
654             continue; // Positioned placeholders don't affect calculations.
655         
656         // Adjust boxes to use their real box y/height and not the logical height (as dictated by
657         // line-height).
658         if (curr->isInlineFlowBox())
659             static_cast<InlineFlowBox*>(curr)->placeBoxesVertically(y, maxHeight, maxAscent, strictMode, topPosition, bottomPosition, selectionTop, selectionBottom);
660
661         bool childAffectsTopBottomPos = true;
662         if (curr->yPos() == PositionTop)
663             curr->setYPos(y);
664         else if (curr->yPos() == PositionBottom)
665             curr->setYPos(y + maxHeight - curr->height());
666         else {
667             if (!curr->hasTextChildren() && !strictMode)
668                 childAffectsTopBottomPos = false;
669             curr->setYPos(curr->yPos() + y + maxAscent - curr->baseline());
670         }
671         
672         int newY = curr->yPos();
673         int newHeight = curr->height();
674         int newBaseline = curr->baseline();
675         int overflowTop = 0;
676         int overflowBottom = 0;
677         if (curr->isText() || curr->isInlineFlowBox()) {
678             const Font& font = curr->object()->font(m_firstLine);
679             newBaseline = font.ascent();
680             newY += curr->baseline() - newBaseline;
681             newHeight = newBaseline + font.descent();
682             for (ShadowData* shadow = curr->object()->style()->textShadow(); shadow; shadow = shadow->next) {
683                 overflowTop = min(overflowTop, shadow->y - shadow->blur);
684                 overflowBottom = max(overflowBottom, shadow->y + shadow->blur);
685             }
686             if (curr->isInlineFlowBox()) {
687                 newHeight += curr->object()->borderTop() + curr->object()->paddingTop() +
688                             curr->object()->borderBottom() + curr->object()->paddingBottom();
689                 newY -= curr->object()->borderTop() + curr->object()->paddingTop();
690                 newBaseline += curr->object()->borderTop() + curr->object()->paddingTop();
691             }
692         }
693         else if (!curr->object()->isBR()) {
694             newY += curr->object()->marginTop();
695             newHeight = curr->height() - (curr->object()->marginTop() + curr->object()->marginBottom());
696             overflowTop = curr->object()->overflowTop(false);
697             overflowBottom = curr->object()->overflowHeight(false) - newHeight;
698         }
699
700         curr->setYPos(newY);
701         curr->setHeight(newHeight);
702         curr->setBaseline(newBaseline);
703
704         if (childAffectsTopBottomPos) {
705             selectionTop = min(selectionTop, newY);
706             selectionBottom = max(selectionBottom, newY + newHeight);
707             topPosition = min(topPosition, newY + overflowTop);
708             bottomPosition = max(bottomPosition, newY + newHeight + overflowBottom);
709         }
710     }
711
712     if (isRootInlineBox()) {
713         const Font& font = object()->font(m_firstLine);
714         setHeight(font.ascent() + font.descent());
715         setYPos(yPos() + baseline() - font.ascent());
716         setBaseline(font.ascent());
717         if (hasTextChildren() || strictMode) {
718             selectionTop = min(selectionTop, yPos());
719             selectionBottom = max(selectionBottom, yPos() + height());
720         }
721     }
722 }
723
724 void InlineFlowBox::shrinkBoxesWithNoTextChildren(int topPos, int bottomPos)
725 {
726     // First shrink our kids.
727     for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
728         if (curr->object()->isPositioned())
729             continue; // Positioned placeholders don't affect calculations.
730         
731         if (curr->isInlineFlowBox())
732             static_cast<InlineFlowBox*>(curr)->shrinkBoxesWithNoTextChildren(topPos, bottomPos);
733     }
734
735     // See if we have text children. If not, then we need to shrink ourselves to fit on the line.
736     if (!hasTextChildren()) {
737         if (yPos() < topPos)
738             setYPos(topPos);
739         if (yPos() + height() > bottomPos)
740             setHeight(bottomPos - yPos());
741         if (baseline() > height())
742             setBaseline(height());
743     }
744 }
745
746 bool InlineFlowBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty)
747 {
748     // Check children first.
749     for (InlineBox* curr = lastChild(); curr; curr = curr->prevOnLine()) {
750         if (!curr->object()->layer() && curr->nodeAtPoint(i, x, y, tx, ty)) {
751             object()->setInnerNode(i);
752             return true;
753         }
754     }
755
756     // Now check ourselves.
757     IntRect rect(tx + m_x, ty + m_y, m_width, m_height);
758     if (object()->style()->visibility() == VISIBLE && rect.contains(x, y)) {
759         object()->setInnerNode(i);
760         return true;
761     }
762     
763     return false;
764 }
765
766 void InlineFlowBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
767 {
768     int xPos = tx + m_x - object()->maximalOutlineSize(i.phase);
769     int w = width() + 2 * object()->maximalOutlineSize(i.phase);
770     bool intersectsDamageRect = xPos < i.r.right() && xPos + w > i.r.x();
771     
772     if (intersectsDamageRect && i.phase != PaintPhaseChildOutlines) {
773         if (i.phase == PaintPhaseOutline || i.phase == PaintPhaseSelfOutline) {
774             // Add ourselves to the paint info struct's list of inlines that need to paint their
775             // outlines.
776             if (object()->style()->visibility() == VISIBLE && object()->style()->outlineWidth() > 0 &&
777                 !object()->isInlineContinuation() && !isRootInlineBox()) {
778                 i.outlineObjects->add(flowObject());
779             }
780         }
781         else {
782             // 1. Paint our background and border.
783             paintBackgroundAndBorder(i, tx, ty);
784             
785             // 2. Paint our underline and overline.
786             paintDecorations(i, tx, ty, false);
787         }
788     }
789
790     PaintPhase paintPhase = i.phase == PaintPhaseChildOutlines ? PaintPhaseOutline : i.phase;
791     RenderObject::PaintInfo childInfo(i);
792     childInfo.phase = paintPhase;
793
794     // 3. Paint our children.
795     if (paintPhase != PaintPhaseSelfOutline) {
796         for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
797             if (!curr->object()->layer())
798                 curr->paint(childInfo, tx, ty);
799         }
800     }
801
802     // 4. Paint our strike-through
803     if (intersectsDamageRect && (i.phase == PaintPhaseForeground || i.phase == PaintPhaseSelection))
804         paintDecorations(i, tx, ty, true);
805 }
806
807 void InlineFlowBox::paintBackgrounds(GraphicsContext* p, const Color& c, const BackgroundLayer* bgLayer,
808                                      int my, int mh, int _tx, int _ty, int w, int h)
809 {
810     if (!bgLayer)
811         return;
812     paintBackgrounds(p, c, bgLayer->next(), my, mh, _tx, _ty, w, h);
813     paintBackground(p, c, bgLayer, my, mh, _tx, _ty, w, h);
814 }
815
816 void InlineFlowBox::paintBackground(GraphicsContext* p, const Color& c, const BackgroundLayer* bgLayer,
817                                     int my, int mh, int _tx, int _ty, int w, int h)
818 {
819     CachedImage* bg = bgLayer->backgroundImage();
820     bool hasBackgroundImage = bg && bg->canRender();
821     if (!hasBackgroundImage || (!prevLineBox() && !nextLineBox()) || !parent())
822         object()->paintBackgroundExtended(p, c, bgLayer, my, mh, _tx, _ty, w, h, 
823                                           borderLeft(), borderRight(), paddingLeft(), paddingRight());
824     else {
825         // We have a background image that spans multiple lines.
826         // We need to adjust _tx and _ty by the width of all previous lines.
827         // Think of background painting on inlines as though you had one long line, a single continuous
828         // strip.  Even though that strip has been broken up across multiple lines, you still paint it
829         // as though you had one single line.  This means each line has to pick up the background where
830         // the previous line left off.
831         // FIXME: What the heck do we do with RTL here? The math we're using is obviously not right,
832         // but it isn't even clear how this should work at all.
833         int xOffsetOnLine = 0;
834         for (InlineRunBox* curr = prevLineBox(); curr; curr = curr->prevLineBox())
835             xOffsetOnLine += curr->width();
836         int startX = _tx - xOffsetOnLine;
837         int totalWidth = xOffsetOnLine;
838         for (InlineRunBox* curr = this; curr; curr = curr->nextLineBox())
839             totalWidth += curr->width();
840         p->save();
841         p->addClip(IntRect(_tx, _ty, width(), height()));
842         object()->paintBackgroundExtended(p, c, bgLayer, my, mh, startX, _ty,
843                                           totalWidth, h, borderLeft(), borderRight(), paddingLeft(), paddingRight());
844         p->restore();
845     }
846 }
847
848 void InlineFlowBox::paintBackgroundAndBorder(RenderObject::PaintInfo& i, int _tx, int _ty)
849 {
850     if (!object()->shouldPaintWithinRoot(i) || object()->style()->visibility() != VISIBLE ||
851         i.phase != PaintPhaseForeground)
852         return;
853
854     // Move x/y to our coordinates.
855     _tx += m_x;
856     _ty += m_y;
857     
858     int w = width();
859     int h = height();
860
861     int my = max(_ty, i.r.y());
862     int mh;
863     if (_ty < i.r.y())
864         mh = max(0, h - (i.r.y() - _ty));
865     else
866         mh = min(i.r.height(), h);
867
868     GraphicsContext* p = i.p;
869     
870     // You can use p::first-line to specify a background. If so, the root line boxes for
871     // a line may actually have to paint a background.
872     RenderStyle* styleToUse = object()->style(m_firstLine);
873     if ((!parent() && m_firstLine && styleToUse != object()->style()) || 
874         (parent() && object()->shouldPaintBackgroundOrBorder())) {
875         Color c = styleToUse->backgroundColor();
876         paintBackgrounds(p, c, styleToUse->backgroundLayers(), my, mh, _tx, _ty, w, h);
877
878         // :first-line cannot be used to put borders on a line. Always paint borders with our
879         // non-first-line style.
880         if (parent() && object()->style()->hasBorder()) {
881             CachedImage* borderImage = object()->style()->borderImage().image();
882             bool hasBorderImage = borderImage && borderImage->canRender();
883             if (hasBorderImage && !borderImage->isLoaded())
884                 return; // Don't paint anything while we wait for the image to load.
885             
886             // The simple case is where we either have no border image or we are the only box for this object.  In those
887             // cases only a single call to draw is required.
888             if (!hasBorderImage || (!prevLineBox() && !nextLineBox()))
889                 object()->paintBorder(p, _tx, _ty, w, h, object()->style(), includeLeftEdge(), includeRightEdge());
890             else {
891                 // We have a border image that spans multiple lines.
892                 // We need to adjust _tx and _ty by the width of all previous lines.
893                 // Think of border image painting on inlines as though you had one long line, a single continuous
894                 // strip.  Even though that strip has been broken up across multiple lines, you still paint it
895                 // as though you had one single line.  This means each line has to pick up the image where
896                 // the previous line left off.
897                 // FIXME: What the heck do we do with RTL here? The math we're using is obviously not right,
898                 // but it isn't even clear how this should work at all.
899                 int xOffsetOnLine = 0;
900                 for (InlineRunBox* curr = prevLineBox(); curr; curr = curr->prevLineBox())
901                     xOffsetOnLine += curr->width();
902                 int startX = _tx - xOffsetOnLine;
903                 int totalWidth = xOffsetOnLine;
904                 for (InlineRunBox* curr = this; curr; curr = curr->nextLineBox())
905                     totalWidth += curr->width();
906                 p->save();
907                 p->addClip(IntRect(_tx, _ty, width(), height()));
908                 object()->paintBorder(p, startX, _ty, totalWidth, h, object()->style());
909                 p->restore();
910             }
911         }
912     }
913 }
914
915 static bool shouldDrawDecoration(RenderObject* obj)
916 {
917     for (RenderObject* curr = obj->firstChild(); curr; curr = curr->nextSibling()) {
918         if (curr->isInlineFlow())
919             return true;
920         if (curr->isText() && !curr->isBR()) {
921             if (!curr->style()->collapseWhiteSpace())
922                 return true;
923             Node* currElement = curr->element();
924             if (!currElement)
925                 return true;
926             if (!currElement->isTextNode())
927                 return true;
928             if (!static_cast<Text*>(currElement)->containsOnlyWhitespace())
929                 return true;
930         }
931     }
932     return false;
933 }
934
935 void InlineFlowBox::paintDecorations(RenderObject::PaintInfo& i, int _tx, int _ty, bool paintedChildren)
936 {
937     // Paint text decorations like underlines/overlines. We only do this if we aren't in quirks mode (i.e., in
938     // almost-strict mode or strict mode).
939     if (object()->style()->htmlHacks() || !object()->shouldPaintWithinRoot(i) ||
940         object()->style()->visibility() != VISIBLE)
941         return;
942
943     GraphicsContext* p = i.p;
944     _tx += m_x;
945     _ty += m_y;
946     RenderStyle* styleToUse = object()->style(m_firstLine);
947     int deco = parent() ? styleToUse->textDecoration() : styleToUse->textDecorationsInEffect();
948     if (deco != TDNONE && 
949         ((!paintedChildren && ((deco & UNDERLINE) || (deco & OVERLINE))) || (paintedChildren && (deco & LINE_THROUGH))) &&
950         shouldDrawDecoration(object())) {
951         int x = m_x + borderLeft() + paddingLeft();
952         int w = m_width - (borderLeft() + paddingLeft() + borderRight() + paddingRight());
953         RootInlineBox* rootLine = root();
954         if (rootLine->ellipsisBox()) {
955             int ellipsisX = rootLine->ellipsisBox()->xPos();
956             int ellipsisWidth = rootLine->ellipsisBox()->width();
957             
958             // FIXME: Will need to work with RTL
959             if (rootLine == this) {
960                 if (x + w >= ellipsisX + ellipsisWidth)
961                     w -= (x + w - ellipsisX - ellipsisWidth);
962             }
963             else {
964                 if (x >= ellipsisX)
965                     return;
966                 if (x + w >= ellipsisX)
967                     w -= (x + w - ellipsisX);
968             }
969         }
970             
971         // Set up the appropriate text-shadow effect for the decoration.
972         // FIXME: Support multiple shadow effects.  Need more from the CG API before we can do this.
973         bool setShadow = false;
974         if (styleToUse->textShadow()) {
975             p->setShadow(IntSize(styleToUse->textShadow()->x, styleToUse->textShadow()->y),
976                          styleToUse->textShadow()->blur, styleToUse->textShadow()->color);
977             setShadow = true;
978         }
979         
980         // We must have child boxes and have decorations defined.
981         _tx += borderLeft() + paddingLeft();
982         
983         Color underline, overline, linethrough;
984         underline = overline = linethrough = styleToUse->color();
985         if (!parent())
986             object()->getTextDecorationColors(deco, underline, overline, linethrough);
987
988         if (styleToUse->font() != p->font())
989             p->setFont(styleToUse->font());
990
991         bool isPrinting = object()->document()->printing();
992         if (deco & UNDERLINE && !paintedChildren) {
993             p->setPen(underline);
994             p->drawLineForText(IntPoint(_tx, _ty), m_baseline, w, isPrinting);
995         }
996         if (deco & OVERLINE && !paintedChildren) {
997             p->setPen(overline);
998             p->drawLineForText(IntPoint(_tx, _ty), 0, w, isPrinting);
999         }
1000         if (deco & LINE_THROUGH && paintedChildren) {
1001             p->setPen(linethrough);
1002             p->drawLineForText(IntPoint(_tx, _ty), 2*m_baseline/3, w, isPrinting);
1003         }
1004
1005         if (setShadow)
1006             p->clearShadow();
1007     }
1008 }
1009
1010 InlineBox* InlineFlowBox::firstLeafChild()
1011 {
1012     return firstLeafChildAfterBox();
1013 }
1014
1015 InlineBox* InlineFlowBox::lastLeafChild()
1016 {
1017     return lastLeafChildBeforeBox();
1018 }
1019
1020 InlineBox* InlineFlowBox::firstLeafChildAfterBox(InlineBox* start)
1021 {
1022     InlineBox* leaf = 0;
1023     for (InlineBox* box = start ? start->nextOnLine() : firstChild(); box && !leaf; box = box->nextOnLine())
1024         leaf = box->firstLeafChild();
1025     if (start && !leaf && parent())
1026         return parent()->firstLeafChildAfterBox(this);
1027     return leaf;
1028 }
1029
1030 InlineBox* InlineFlowBox::lastLeafChildBeforeBox(InlineBox* start)
1031 {
1032     InlineBox* leaf = 0;
1033     for (InlineBox* box = start ? start->prevOnLine() : lastChild(); box && !leaf; box = box->prevOnLine())
1034         leaf = box->lastLeafChild();
1035     if (start && !leaf && parent())
1036         return parent()->lastLeafChildBeforeBox(this);
1037     return leaf;
1038 }
1039
1040 RenderObject::SelectionState InlineFlowBox::selectionState()
1041 {
1042     return RenderObject::SelectionNone;
1043 }
1044
1045 bool InlineFlowBox::canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth)
1046 {
1047     for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) {
1048         if (!box->canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth))
1049             return false;
1050     }
1051     return true;
1052 }
1053
1054 int InlineFlowBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox)
1055 {
1056     int result = -1;
1057     for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) {
1058         int currResult = box->placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox);
1059         if (currResult != -1 && result == -1)
1060             result = currResult;
1061     }
1062     return result;
1063 }
1064
1065 void InlineFlowBox::clearTruncation()
1066 {
1067     for (InlineBox *box = firstChild(); box; box = box->nextOnLine())
1068         box->clearTruncation();
1069 }
1070
1071 void EllipsisBox::paint(RenderObject::PaintInfo& i, int _tx, int _ty)
1072 {
1073     GraphicsContext* p = i.p;
1074     RenderStyle* _style = m_firstLine ? m_object->firstLineStyle() : m_object->style();
1075     if (_style->font() != p->font())
1076         p->setFont(_style->font());
1077
1078     Color textColor = _style->color();
1079     if (textColor != p->pen().color())
1080         p->setPen(textColor);
1081     bool setShadow = false;
1082     if (_style->textShadow()) {
1083         p->setShadow(IntSize(_style->textShadow()->x, _style->textShadow()->y),
1084                      _style->textShadow()->blur, _style->textShadow()->color);
1085         setShadow = true;
1086     }
1087
1088     const String& str = m_str;
1089     p->drawText(TextRun(str.impl()), IntPoint(m_x + _tx, m_y + _ty + m_baseline), 0, 0, 0, LTR, _style->visuallyOrdered());
1090
1091     if (setShadow)
1092         p->clearShadow();
1093
1094     if (m_markupBox) {
1095         // Paint the markup box
1096         _tx += m_x + m_width - m_markupBox->xPos();
1097         _ty += m_y + m_baseline - (m_markupBox->yPos() + m_markupBox->baseline());
1098         m_markupBox->paint(i, _tx, _ty);
1099     }
1100 }
1101
1102 bool EllipsisBox::nodeAtPoint(RenderObject::NodeInfo& info, int x, int y, int tx, int ty)
1103 {
1104     tx += m_x;
1105     ty += m_y;
1106
1107     // Hit test the markup box.
1108     if (m_markupBox) {
1109         int mtx = tx + m_width - m_markupBox->xPos();
1110         int mty = ty + m_baseline - (m_markupBox->yPos() + m_markupBox->baseline());
1111         if (m_markupBox->nodeAtPoint(info, x, y, mtx, mty)) {
1112             object()->setInnerNode(info);
1113             return true;
1114         }
1115     }
1116
1117     if (object()->style()->visibility() == VISIBLE && IntRect(tx, ty, m_width, m_height).contains(x, y)) {
1118         object()->setInnerNode(info);
1119         return true;
1120     }
1121
1122     return false;
1123 }
1124
1125 void RootInlineBox::destroy(RenderArena* arena)
1126 {
1127     detachEllipsisBox(arena);
1128     InlineFlowBox::destroy(arena);
1129 }
1130
1131 void RootInlineBox::detachEllipsisBox(RenderArena* arena)
1132 {
1133     if (m_ellipsisBox) {
1134         m_ellipsisBox->destroy(arena);
1135         m_ellipsisBox = 0;
1136     }
1137 }
1138
1139 void RootInlineBox::clearTruncation()
1140 {
1141     if (m_ellipsisBox) {
1142         detachEllipsisBox(m_object->renderArena());
1143         InlineFlowBox::clearTruncation();
1144     }
1145 }
1146
1147 bool RootInlineBox::canAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth)
1148 {
1149     // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room.
1150     int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge;
1151     if (width() - delta < ellipsisWidth)
1152         return false;
1153
1154     // Next iterate over all the line boxes on the line.  If we find a replaced element that intersects
1155     // then we refuse to accommodate the ellipsis.  Otherwise we're ok.
1156     return InlineFlowBox::canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth);
1157 }
1158
1159 void RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr,  bool ltr, int blockEdge, int ellipsisWidth,
1160                                   InlineBox* markupBox)
1161 {
1162     // Create an ellipsis box.
1163     m_ellipsisBox = new (m_object->renderArena()) EllipsisBox(m_object, ellipsisStr, this, 
1164                                                               ellipsisWidth - (markupBox ? markupBox->width() : 0),
1165                                                               yPos(), height(), baseline(), !prevRootBox(),
1166                                                               markupBox);
1167
1168     if (ltr && (xPos() + width() + ellipsisWidth) <= blockEdge) {
1169         m_ellipsisBox->m_x = xPos() + width();
1170         return;
1171     }
1172
1173     // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL)
1174     // of that glyph.  Mark all of the objects that intersect the ellipsis box as not painting (as being
1175     // truncated).
1176     bool foundBox = false;
1177     m_ellipsisBox->m_x = placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox);
1178 }
1179
1180 int RootInlineBox::placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool& foundBox)
1181 {
1182     int result = InlineFlowBox::placeEllipsisBox(ltr, blockEdge, ellipsisWidth, foundBox);
1183     if (result == -1)
1184         result = ltr ? blockEdge - ellipsisWidth : blockEdge;
1185     return result;
1186 }
1187
1188 void RootInlineBox::paintEllipsisBox(RenderObject::PaintInfo& i, int _tx, int _ty) const
1189 {
1190     if (m_ellipsisBox && object()->shouldPaintWithinRoot(i) && object()->style()->visibility() == VISIBLE &&
1191         i.phase == PaintPhaseForeground)
1192         m_ellipsisBox->paint(i, _tx, _ty);
1193 }
1194
1195 void RootInlineBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
1196 {
1197     InlineFlowBox::paint(i, tx, ty);
1198     paintEllipsisBox(i, tx, ty);
1199 }
1200
1201 bool RootInlineBox::nodeAtPoint(RenderObject::NodeInfo& i, int x, int y, int tx, int ty)
1202 {
1203     if (m_ellipsisBox && object()->style()->visibility() == VISIBLE) {
1204         if (m_ellipsisBox->nodeAtPoint(i, x, y, tx, ty)) {
1205             object()->setInnerNode(i);
1206             return true;
1207         }
1208     }
1209     return InlineFlowBox::nodeAtPoint(i, x, y, tx, ty);
1210 }
1211
1212 void RootInlineBox::adjustPosition(int dx, int dy)
1213 {
1214     InlineFlowBox::adjustPosition(dx, dy);
1215     m_topOverflow += dy;
1216     m_bottomOverflow += dy;
1217     m_blockHeight += dy;
1218 }
1219
1220 void RootInlineBox::childRemoved(InlineBox* box)
1221 {
1222     if (box->object() == m_lineBreakObj)
1223         setLineBreakInfo(0, 0, 0, 0);
1224
1225     RootInlineBox* prev = prevRootBox();
1226     if (prev && prev->lineBreakObj() == box->object()) {
1227         prev->setLineBreakInfo(0, 0, 0, 0);
1228         prev->markDirty();
1229     }
1230 }
1231
1232 GapRects RootInlineBox::fillLineSelectionGap(int selTop, int selHeight, RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty, 
1233                                              const RenderObject::PaintInfo* i)
1234 {
1235     GapRects result;
1236     RenderObject::SelectionState lineState = selectionState();
1237
1238     bool leftGap, rightGap;
1239     block()->getHorizontalSelectionGapInfo(lineState, leftGap, rightGap);
1240
1241     InlineBox* firstBox = firstSelectedBox();
1242     InlineBox* lastBox = lastSelectedBox();
1243     if (leftGap)
1244         result.uniteLeft(block()->fillLeftSelectionGap(firstBox->parent()->object(), 
1245                                                        firstBox->xPos(), selTop, selHeight, 
1246                                                        rootBlock, blockX, blockY, tx, ty, i));
1247     if (rightGap)
1248         result.uniteRight(block()->fillRightSelectionGap(lastBox->parent()->object(), 
1249                                                          lastBox->xPos() + lastBox->width(), selTop, selHeight, 
1250                                                          rootBlock, blockX, blockY, tx, ty, i));
1251
1252     if (firstBox && firstBox != lastBox) {
1253         // Now fill in any gaps on the line that occurred between two selected elements.
1254         int lastX = firstBox->xPos() + firstBox->width();
1255         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
1256             if (box->selectionState() != RenderObject::SelectionNone) {
1257                 result.uniteCenter(block()->fillHorizontalSelectionGap(box->parent()->object(),
1258                                                                        lastX + tx, selTop + ty,
1259                                                                        box->xPos() - lastX, selHeight, i));
1260                 lastX = box->xPos() + box->width();
1261             }
1262             if (box == lastBox)
1263                 break;
1264         }
1265     }
1266       
1267     return result;
1268 }
1269
1270 void RootInlineBox::setHasSelectedChildren(bool b)
1271 {
1272     if (m_hasSelectedChildren == b)
1273         return;
1274     m_hasSelectedChildren = b;
1275 }
1276
1277 RenderObject::SelectionState RootInlineBox::selectionState()
1278 {
1279     // Walk over all of the selected boxes.
1280     RenderObject::SelectionState state = RenderObject::SelectionNone;
1281     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
1282         RenderObject::SelectionState boxState = box->selectionState();
1283         if ((boxState == RenderObject::SelectionStart && state == RenderObject::SelectionEnd) ||
1284             (boxState == RenderObject::SelectionEnd && state == RenderObject::SelectionStart))
1285             state = RenderObject::SelectionBoth;
1286         else if (state == RenderObject::SelectionNone ||
1287                  ((boxState == RenderObject::SelectionStart || boxState == RenderObject::SelectionEnd) &&
1288                   (state == RenderObject::SelectionNone || state == RenderObject::SelectionInside)))
1289             state = boxState;
1290         if (state == RenderObject::SelectionBoth)
1291             break;
1292     }
1293     
1294     return state;
1295 }
1296
1297 InlineBox* RootInlineBox::firstSelectedBox()
1298 {
1299     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild())
1300         if (box->selectionState() != RenderObject::SelectionNone)
1301             return box;
1302     return 0;
1303 }
1304
1305 InlineBox* RootInlineBox::lastSelectedBox()
1306 {
1307     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild())
1308         if (box->selectionState() != RenderObject::SelectionNone)
1309             return box;
1310     return 0;
1311 }
1312
1313 int RootInlineBox::selectionTop()
1314 {
1315     if (!prevRootBox())
1316         return m_selectionTop;
1317     
1318     int prevBottom = prevRootBox()->selectionBottom();
1319     if (prevBottom < m_selectionTop && block()->containsFloats()) {
1320         // This line has actually been moved further down, probably from a large line-height, but possibly because the
1321         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the previous
1322         // line's bottom overflow if the offsets are greater on both sides.
1323         int prevLeft = block()->leftOffset(prevBottom);
1324         int prevRight = block()->rightOffset(prevBottom);
1325         int newLeft = block()->leftOffset(m_selectionTop);
1326         int newRight = block()->rightOffset(m_selectionTop);
1327         if (prevLeft > newLeft || prevRight < newRight)
1328             return m_selectionTop;
1329     }
1330     
1331     return prevBottom;
1332 }
1333  
1334 RenderBlock* RootInlineBox::block() const
1335 {
1336     return static_cast<RenderBlock*>(m_object);
1337 }
1338
1339 InlineBox* RootInlineBox::closestLeafChildForXPos(int _x, int _tx)
1340 {
1341     InlineBox *firstLeaf = firstLeafChildAfterBox();
1342     InlineBox *lastLeaf = lastLeafChildBeforeBox();
1343     if (firstLeaf == lastLeaf)
1344         return firstLeaf;
1345     
1346     // Avoid returning a list marker when possible.
1347     if (_x <= _tx + firstLeaf->m_x && !firstLeaf->object()->isListMarker())
1348         // The x coordinate is less or equal to left edge of the firstLeaf.
1349         // Return it.
1350         return firstLeaf;
1351     
1352     if (_x >= _tx + lastLeaf->m_x + lastLeaf->m_width && !lastLeaf->object()->isListMarker())
1353         // The x coordinate is greater or equal to right edge of the lastLeaf.
1354         // Return it.
1355         return lastLeaf;
1356
1357     for (InlineBox *leaf = firstLeaf; leaf && leaf != lastLeaf; leaf = leaf->nextLeafChild()) {
1358         if (!leaf->object()->isListMarker()) {
1359             int leafX = _tx + leaf->m_x;
1360             if (_x < leafX + leaf->m_width)
1361                 // The x coordinate is less than the right edge of the box.
1362                 // Return it.
1363                 return leaf;
1364         }
1365     }
1366
1367     return lastLeaf;
1368 }
1369
1370 void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, BidiStatus* status, BidiContext* context)
1371 {
1372     m_lineBreakObj = obj;
1373     m_lineBreakPos = breakPos;
1374     m_lineBreakContext = context;
1375     if (status)
1376         m_lineBreakBidiStatus = *status;
1377 }
1378
1379 }
1380
1381 #ifndef NDEBUG
1382
1383 void showTree(const WebCore::InlineBox* b)
1384 {
1385     if (b)
1386         b->showTreeForThis();
1387 }
1388
1389 #endif