Reviewed by Darin, landed by ap.
[WebKit-https.git] / WebCore / rendering / RenderBox.cpp
1 /**
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
6  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
7  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
8  * Copyright (C) 2005 Apple Computer, Inc.
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23  * Boston, MA 02111-1307, USA.
24  *
25  */
26
27 #include "config.h"
28 #include "RenderBox.h"
29
30 #include "CachedImage.h"
31 #include "Document.h"
32 #include "FrameView.h"
33 #include "GraphicsContext.h"
34 #include "HTMLElement.h"
35 #include "HTMLNames.h"
36 #include "RenderArena.h"
37 #include "RenderView.h"
38 #include "RenderFlexibleBox.h"
39 #include "RenderTableCell.h"
40 #include "RenderTheme.h"
41 #include <assert.h>
42 #include <algorithm>
43 #include <math.h>
44
45 using namespace std;
46
47 namespace WebCore {
48
49 using namespace HTMLNames;
50
51 #define TABLECELLMARGIN -0x4000
52
53 RenderBox::RenderBox(WebCore::Node* node)
54     : RenderObject(node)
55 {
56     m_minWidth = -1;
57     m_maxWidth = -1;
58     m_overrideSize = -1;
59     m_width = m_height = 0;
60     m_x = 0;
61     m_y = 0;
62     m_marginTop = 0;
63     m_marginBottom = 0;
64     m_marginLeft = 0;
65     m_marginRight = 0;
66     m_staticX = 0;
67     m_staticY = 0;
68     m_layer = 0;
69     m_inlineBoxWrapper = 0;
70 }
71
72 static RenderBlock* blockThatPaintsFloat(RenderObject* f)
73 {
74     RenderBlock* lastBlock = 0;
75     for (RenderObject* o = f->parent(); o; o = o->parent()) {
76         if (lastBlock && o->layer())
77             break;
78         if (o->isRenderBlock())
79             lastBlock = static_cast<RenderBlock*>(o);
80     }
81     return lastBlock;
82 }
83
84 void RenderBox::setStyle(RenderStyle *_style)
85 {
86     bool wasFloating = isFloating();
87
88     RenderObject::setStyle(_style);
89
90     // The root always paints its background/border.
91     if (isRoot())
92         setShouldPaintBackgroundOrBorder(true);
93
94     setInline(_style->isDisplayInlineType());
95
96     switch (_style->position()) {
97         case AbsolutePosition:
98         case FixedPosition:
99             setPositioned(true);
100             break;
101         default:
102             setPositioned(false);
103
104             if (_style->isFloating())
105                 setFloating(true);
106
107             if (_style->position() == RelativePosition)
108                 setRelPositioned(true);
109     }
110
111     // We also handle <body> and <html>, whose overflow applies to the viewport.
112     if (!isRoot() && (!isBody() || !document()->isHTMLDocument()) && (isRenderBlock() || isTableRow() || isTableSection())) {
113         // Check for overflow clip.
114         // It's sufficient to just check one direction, since it's illegal to have visible on only one overflow value.
115         if (_style->overflowX() != OVISIBLE)
116             setHasOverflowClip();
117     }
118
119     if (requiresLayer()) {
120         if (!m_layer) {
121             if (wasFloating && isFloating()) {
122                 if (RenderBlock* b = blockThatPaintsFloat(this))
123                     b->setPaintsFloatingObject(this, false);
124             }
125             m_layer = new (renderArena()) RenderLayer(this);
126             m_layer->insertOnlyThisLayer();
127             if (parent() && !needsLayout() && containingBlock())
128                 m_layer->updateLayerPositions();
129         }
130     } else if (m_layer && !isRoot() && !isRenderView()) {
131         assert(m_layer->parent());
132         RenderLayer* layer = m_layer;
133         m_layer = 0;
134         layer->removeOnlyThisLayer();
135         if (wasFloating && isFloating()) {
136             if (RenderBlock* b = blockThatPaintsFloat(this))
137                 b->setPaintsFloatingObject(this, true);
138         }
139     }
140
141     if (m_layer)
142         m_layer->styleChanged();
143     
144     // Set the text color if we're the body.
145     if (isBody())
146         element()->document()->setTextColor(_style->color());
147     
148     if (style()->outlineWidth() > 0 && style()->outlineSize() > maximalOutlineSize(PaintPhaseOutline))
149         static_cast<RenderView*>(document()->renderer())->setMaximalOutlineSize(style()->outlineSize());
150 }
151
152 RenderBox::~RenderBox()
153 {
154 }
155
156 void RenderBox::destroy()
157 {
158     // A lot of the code in this funtion is just pasted into
159     // RenderWidget::destroy. If anything in this function changes,
160     // be sure to fix RenderWidget::destroy() as well. 
161
162     RenderLayer* layer = m_layer;
163     RenderArena* arena = renderArena();
164     
165     // This must be done before we destroy the RenderObject.
166     if (layer)
167         layer->clearClipRect();
168
169     RenderObject::destroy();
170     
171     if (layer)
172         layer->destroy(arena);
173 }
174
175 int RenderBox::contentWidth() const
176 {
177     int w = m_width - (borderLeft() + borderRight() + paddingLeft() + paddingRight());
178
179     if (includeVerticalScrollbarSize())
180         w -= m_layer->verticalScrollbarWidth();
181     
182     return w;
183 }
184
185 int RenderBox::contentHeight() const
186 {
187     int h = m_height - (borderTop() + borderBottom() + paddingTop() + paddingBottom());
188
189     if (includeHorizontalScrollbarSize())
190         h -= m_layer->horizontalScrollbarHeight();
191
192     return h;
193 }
194
195 int RenderBox::overrideWidth() const
196 {
197     return m_overrideSize == -1 ? m_width : m_overrideSize;
198 }
199
200 int RenderBox::overrideHeight() const
201 {
202     return m_overrideSize == -1 ? m_height : m_overrideSize;
203 }
204
205 void RenderBox::setPos(int xPos, int yPos)
206 {
207     if (xPos == m_x && yPos == m_y)
208         return; // Optimize for the case where we don't move at all.
209     
210     m_x = xPos;
211     m_y = yPos;
212 }
213
214 int RenderBox::width() const
215 {
216     return m_width;
217 }
218
219 int RenderBox::height() const
220 {
221     return m_height;
222 }
223
224 int RenderBox::calcBorderBoxWidth(int w) const
225 {
226     int toAdd = borderLeft() + borderRight() + paddingLeft() + paddingRight();
227     if (style()->boxSizing() == CONTENT_BOX)
228         return w + toAdd;
229     return max(w, toAdd);
230 }
231
232 int RenderBox::calcBorderBoxHeight(int h) const
233 {
234     int toAdd = borderTop() + borderBottom() + paddingTop() + paddingBottom();
235     if (style()->boxSizing() == CONTENT_BOX)
236         return h + toAdd;
237     return max(h, toAdd);
238 }
239
240 int RenderBox::calcContentBoxWidth(int w) const
241 {
242     if (style()->boxSizing() == BORDER_BOX)
243         w -= (borderLeft() + borderRight() + paddingLeft() + paddingRight());
244     return max(0, w);
245 }
246
247 int RenderBox::calcContentBoxHeight(int h) const
248 {
249     if (style()->boxSizing() == BORDER_BOX)
250         h -= (borderTop() + borderBottom() + paddingTop() + paddingBottom());
251     return max(0, h);
252 }
253
254 // Hit Testing
255 bool RenderBox::nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action)
256 {
257     tx += m_x;
258     ty += m_y;
259
260     // Check kids first.
261     for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
262         // FIXME: We have to skip over inline flows, since they can show up inside table rows
263         // at the moment (a demoted inline <form> for example). If we ever implement a
264         // table-specific hit-test method (which we should do for performance reasons anyway),
265         // then we can remove this check.
266         if (!child->layer() && !child->isInlineFlow() && child->nodeAtPoint(info, x, y, tx, ty, action)) {
267             setInnerNode(info);
268             return true;
269         }
270     }
271     
272     // Check our bounds next. For this purpose always assume that we can only be hit in the
273     // foreground phase (which is true for replaced elements like images).
274     if (action == HitTestForeground && IntRect(tx, ty, m_width, m_height).contains(x, y)) {
275         setInnerNode(info);
276         return true;
277     }
278
279     return false;
280 }
281
282 // --------------------- painting stuff -------------------------------
283
284 void RenderBox::paint(PaintInfo& i, int _tx, int _ty)
285 {
286     _tx += m_x;
287     _ty += m_y;
288
289     // default implementation. Just pass paint through to the children
290     for (RenderObject* child = firstChild(); child; child = child->nextSibling())
291         child->paint(i, _tx, _ty);
292 }
293
294 void RenderBox::paintRootBoxDecorations(PaintInfo& i, int _tx, int _ty)
295 {
296     const BackgroundLayer* bgLayer = style()->backgroundLayers();
297     Color bgColor = style()->backgroundColor();
298     if (document()->isHTMLDocument() && !style()->hasBackground()) {
299         // Locate the <body> element using the DOM.  This is easier than trying
300         // to crawl around a render tree with potential :before/:after content and
301         // anonymous blocks created by inline <body> tags etc.  We can locate the <body>
302         // render object very easily via the DOM.
303         HTMLElement* body = document()->body();
304         RenderObject* bodyObject = (body && body->hasLocalName(bodyTag)) ? body->renderer() : 0;
305         if (bodyObject) {
306             bgLayer = bodyObject->style()->backgroundLayers();
307             bgColor = bodyObject->style()->backgroundColor();
308         }
309     }
310
311     int w = width();
312     int h = height();
313
314     int rw, rh;
315     if (view()->frameView()) {
316         rw = view()->frameView()->contentsWidth();
317         rh = view()->frameView()->contentsHeight();
318     }
319     else {
320         rw = view()->width();
321         rh = view()->height();
322     }
323     
324     int bx = _tx - marginLeft();
325     int by = _ty - marginTop();
326     int bw = max(w + marginLeft() + marginRight() + borderLeft() + borderRight(), rw);
327     int bh = max(h + marginTop() + marginBottom() + borderTop() + borderBottom(), rh);
328
329     // CSS2 14.2:
330     // " The background of the box generated by the root element covers the entire canvas."
331     // hence, paint the background even in the margin areas (unlike for every other element!)
332     // I just love these little inconsistencies .. :-( (Dirk)
333     int my = max(by, i.r.y());
334
335     paintBackgrounds(i.p, bgColor, bgLayer, my, i.r.height(), bx, by, bw, bh);
336
337     if (style()->hasBorder() && style()->display() != INLINE)
338         paintBorder( i.p, _tx, _ty, w, h, style() );
339 }
340
341 void RenderBox::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
342 {
343     if (!shouldPaintWithinRoot(i))
344         return;
345
346     if (isRoot())
347         return paintRootBoxDecorations(i, _tx, _ty);
348     
349     int w = width();
350     int h = height() + borderTopExtra() + borderBottomExtra();
351     _ty -= borderTopExtra();
352
353     int my = max(_ty, i.r.y());
354     int mh;
355     if (_ty < i.r.y())
356         mh = max(0, h - (i.r.y() - _ty));
357     else
358         mh = min(i.r.height(), h);
359
360     // If we have a native theme appearance, paint that before painting our background.  
361     // The theme will tell us whether or not we should also paint the CSS background.
362     bool themePainted = style()->hasAppearance() && !theme()->paint(this, i, IntRect(_tx, _ty, w, h));
363     if (!themePainted) {
364         // The <body> only paints its background if the root element has defined a background
365         // independent of the body.  Go through the DOM to get to the root element's render object,
366         // since the root could be inline and wrapped in an anonymous block.
367         if (!isBody() || !document()->isHTMLDocument() || document()->documentElement()->renderer()->style()->hasBackground())
368             paintBackgrounds(i.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, _tx, _ty, w, h);
369     }
370     
371     // The theme will tell us whether or not we should also paint the CSS border.
372     if ((!style()->hasAppearance() || (!themePainted && theme()->paintBorderOnly(this, i, IntRect(_tx, _ty, w, h)))) && style()->hasBorder())
373         paintBorder(i.p, _tx, _ty, w, h, style());
374 }
375
376 void RenderBox::paintBackgrounds(GraphicsContext* p, const Color& c, const BackgroundLayer* bgLayer, int clipy, int cliph, int _tx, int _ty, int w, int height)
377 {
378     if (!bgLayer) return;
379     paintBackgrounds(p, c, bgLayer->next(), clipy, cliph, _tx, _ty, w, height);
380     paintBackground(p, c, bgLayer, clipy, cliph, _tx, _ty, w, height);
381 }
382
383 void RenderBox::paintBackground(GraphicsContext* p, const Color& c, const BackgroundLayer* bgLayer, int clipy, int cliph, int _tx, int _ty, int w, int height)
384 {
385     paintBackgroundExtended(p, c, bgLayer, clipy, cliph, _tx, _ty, w, height,
386                             borderLeft(), borderRight(), paddingLeft(), paddingRight());
387 }
388
389 static void cacluateBackgroundSize(const BackgroundLayer* bgLayer, int& scaledWidth, int& scaledHeight)
390 {
391     CachedImage* bg = bgLayer->backgroundImage();
392     
393     if (bgLayer->isBackgroundSizeSet()) {
394         Length bgWidth = bgLayer->backgroundSize().width;
395         Length bgHeight = bgLayer->backgroundSize().height;
396         
397         if (bgWidth.isPercent())
398             scaledWidth = scaledWidth * bgWidth.value() / 100;
399         else if (bgWidth.isFixed())
400             scaledWidth = bgWidth.value();
401         else if (bgWidth.isAuto()) {
402             // If the width is auto and the height is not, we have to use the appropriate
403             // scale to maintain our aspect ratio.
404             if (bgHeight.isPercent()) {
405                 int scaledH = scaledHeight * bgHeight.value() / 100;
406                 scaledWidth = bg->imageSize().width() * scaledH / bg->imageSize().height();
407             } else if (bgHeight.isFixed())
408                 scaledWidth = bg->imageSize().width() * bgHeight.value() / bg->imageSize().height();
409         }
410             
411         if (bgHeight.isPercent())
412             scaledHeight = scaledHeight * bgHeight.value() / 100;
413         else if (bgHeight.isFixed())
414             scaledHeight = bgHeight.value();
415         else if (bgHeight.isAuto()) {
416             // If the height is auto and the width is not, we have to use the appropriate
417             // scale to maintain our aspect ratio.
418             if (bgWidth.isPercent())
419                 scaledHeight = bg->imageSize().height() * scaledWidth / bg->imageSize().width();
420             else if (bgWidth.isFixed())
421                 scaledHeight = bg->imageSize().height() * bgWidth.value() / bg->imageSize().width();
422             else if (bgWidth.isAuto()) {
423                 // If both width and height are auto, we just want to use the image's
424                 // intrinsic size.
425                 scaledWidth = bg->imageSize().width();
426                 scaledHeight = bg->imageSize().height();
427             }
428         }
429     } else {
430         scaledWidth = bg->imageSize().width();
431         scaledHeight = bg->imageSize().height();
432     }
433 }
434
435 void RenderBox::paintBackgroundExtended(GraphicsContext* p, const Color& c, const BackgroundLayer* bgLayer, int clipy, int cliph,
436                                         int _tx, int _ty, int w, int h,
437                                         int bleft, int bright, int pleft, int pright)
438 {
439     bool clippedToBorderRadius = false;
440     if (style()->hasBorderRadius()) {
441         p->save();
442         p->addRoundedRectClip(IntRect(_tx, _ty, w, h),
443             style()->borderTopLeftRadius(), style()->borderTopRightRadius(),
444             style()->borderBottomLeftRadius(), style()->borderBottomRightRadius());
445         clippedToBorderRadius = true;
446     }
447     
448     if (bgLayer->backgroundClip() != BGBORDER) {
449         // Clip to the padding or content boxes as necessary.
450         bool includePadding = bgLayer->backgroundClip() == BGCONTENT;
451         int x = _tx + bleft + (includePadding ? pleft : 0);
452         int y = _ty + borderTop() + (includePadding ? paddingTop() : 0);
453         int width = w - bleft - bright - (includePadding ? pleft + pright : 0);
454         int height = h - borderTop() - borderBottom() - (includePadding ? paddingTop() + paddingBottom() : 0);
455         p->save();
456         p->addClip(IntRect(x, y, width, height));
457     }
458
459     CachedImage* bg = bgLayer->backgroundImage();
460     bool shouldPaintBackgroundImage = bg && bg->canRender();
461     Color bgColor = c;
462     
463     // When this style flag is set, change existing background colors and images to a solid white background.
464     // If there's no bg color or image, leave it untouched to avoid affecting transparency.
465     // We don't try to avoid loading the background images, because this style flag is only set
466     // when printing, and at that point we've already loaded the background images anyway. (To avoid
467     // loading the background images we'd have to do this check when applying styles rather than
468     // while rendering.)
469     if (style()->forceBackgroundsToWhite()) {
470         // Note that we can't reuse this variable below because the bgColor might be changed
471         bool shouldPaintBackgroundColor = !bgLayer->next() && bgColor.isValid() && bgColor.alpha() > 0;
472         if (shouldPaintBackgroundImage || shouldPaintBackgroundColor) {
473             bgColor = Color::white;
474             shouldPaintBackgroundImage = false;
475         }
476     }
477
478     // Only fill with a base color (e.g., white) if we're the root document, since iframes/frames with
479     // no background in the child document should show the parent's background.
480     if (!bgLayer->next() && isRoot() && !(bgColor.isValid() && bgColor.alpha() > 0) && view()->frameView()) {
481         bool isTransparent;
482         WebCore::Node* elt = document()->ownerElement();
483         if (elt) {
484             if (elt->hasTagName(frameTag))
485                 isTransparent = false;
486             else {
487                 // Locate the <body> element using the DOM.  This is easier than trying
488                 // to crawl around a render tree with potential :before/:after content and
489                 // anonymous blocks created by inline <body> tags etc.  We can locate the <body>
490                 // render object very easily via the DOM.
491                 HTMLElement* body = document()->body();
492                 isTransparent = !body || !body->hasLocalName(framesetTag); // Can't scroll a frameset document anyway.
493             }
494         } else
495             isTransparent = view()->frameView()->isTransparent();
496         
497         if (isTransparent)
498             view()->frameView()->useSlowRepaints(); // The parent must show behind the child.
499         else
500             bgColor = Color::white;
501     }
502
503     // Paint the color first underneath all images.
504     if (!bgLayer->next() && bgColor.isValid() && bgColor.alpha() > 0) {
505         IntRect rect(_tx, clipy, w, cliph);
506         // If we have an alpha and we are painting the root element, go ahead and blend with white.
507         if (bgColor.alpha() < 0xFF && isRoot() && !view()->frameView()->isTransparent())
508             p->fillRect(rect, Color(Color::white));
509         p->fillRect(rect, bgColor);
510     }
511     
512     // no progressive loading of the background image
513     if (shouldPaintBackgroundImage) {
514         int sx = 0;
515         int sy = 0;
516         int cw,ch;
517         int cx,cy;
518         int scaledImageWidth, scaledImageHeight;
519
520         
521         // CSS2 chapter 14.2.1
522
523         if (bgLayer->backgroundAttachment()) {
524             // scroll
525             int hpab = 0, vpab = 0, left = 0, top = 0; // Init to 0 for background-origin of 'border'
526             if (bgLayer->backgroundOrigin() != BGBORDER) {
527                 hpab += bleft + bright;
528                 vpab += borderTop() + borderBottom();
529                 left += bleft;
530                 top += borderTop();
531                 if (bgLayer->backgroundOrigin() == BGCONTENT) {
532                     hpab += pleft + pright;
533                     vpab += paddingTop() + paddingBottom();
534                     left += pleft;
535                     top += paddingTop();
536                 }
537             }
538             
539             int pw = w - hpab;
540             int ph = h - vpab;
541             scaledImageWidth = pw;
542             scaledImageHeight = ph;
543             cacluateBackgroundSize(bgLayer, scaledImageWidth, scaledImageHeight);
544
545             EBackgroundRepeat bgr = bgLayer->backgroundRepeat();
546             if ((bgr == NO_REPEAT || bgr == REPEAT_Y) && w > scaledImageWidth) {
547                 cw = scaledImageWidth;
548                 int xPosition = bgLayer->backgroundXPosition().calcMinValue(pw - scaledImageWidth);
549                 if (xPosition >= 0)
550                     cx = _tx + xPosition;
551                 else {
552                     cx = _tx;
553                     if (scaledImageWidth > 0) {
554                         sx = -xPosition;
555                         cw += xPosition;
556                     }
557                 }
558                 cx += left;
559             } else {
560                 // repeat over x or background is wider than box
561                 cw = w;
562                 cx = _tx;
563                 if (scaledImageWidth > 0) {
564                     int xPosition = bgLayer->backgroundXPosition().calcMinValue(pw - scaledImageWidth);
565                     if ((xPosition > 0) && (bgr == NO_REPEAT)) {
566                         cx += xPosition;
567                         cw -= xPosition;
568                     } else {
569                         sx = scaledImageWidth - (xPosition % scaledImageWidth);
570                         sx -= left % scaledImageWidth;
571                     }
572                 }
573             }
574
575             if((bgr == NO_REPEAT || bgr == REPEAT_X) && h > scaledImageHeight) {
576                 ch = scaledImageHeight;
577                 int yPosition = bgLayer->backgroundYPosition().calcMinValue(ph - scaledImageHeight);
578                 if (yPosition >= 0)
579                     cy = _ty + yPosition;
580                 else {
581                     cy = _ty;
582                     if (scaledImageHeight > 0) {
583                         sy = -yPosition;
584                         ch += yPosition;
585                     }
586                 }
587                 
588                 cy += top;
589             } else {
590                 // repeat over y or background is taller than box
591                 ch = h;
592                 cy = _ty;
593                 if (scaledImageHeight > 0) {
594                     int yPosition = bgLayer->backgroundYPosition().calcMinValue(ph - scaledImageHeight);
595                     if ((yPosition > 0) && (bgr == NO_REPEAT)) {
596                         cy += yPosition;
597                         ch -= yPosition;
598                     } else {
599                         sy = scaledImageHeight - (yPosition % scaledImageHeight);
600                         sy -= top % scaledImageHeight;
601                     }
602                 }
603             }
604         }
605         else {
606             //fixed
607             IntRect vr = viewRect();
608             int pw = vr.width();
609             int ph = vr.height();
610             scaledImageWidth = pw;
611             scaledImageHeight = ph;
612             cacluateBackgroundSize(bgLayer, scaledImageWidth, scaledImageHeight);
613             EBackgroundRepeat bgr = bgLayer->backgroundRepeat();
614             
615             if ((bgr == NO_REPEAT || bgr == REPEAT_Y) && pw > scaledImageWidth) {
616                 cw = scaledImageWidth;
617                 cx = vr.x() + bgLayer->backgroundXPosition().calcMinValue(pw - scaledImageWidth);
618             } else {
619                 cw = pw;
620                 cx = vr.x();
621                 if (scaledImageWidth > 0)
622                     sx = scaledImageWidth - bgLayer->backgroundXPosition().calcMinValue(pw - scaledImageWidth) % scaledImageWidth;
623             }
624
625             if ((bgr == NO_REPEAT || bgr == REPEAT_X) && ph > scaledImageHeight) {
626                 ch = scaledImageHeight;
627                 cy = vr.y() + bgLayer->backgroundYPosition().calcMinValue(ph - scaledImageHeight);
628             } else {
629                 ch = ph;
630                 cy = vr.y();
631                 if (scaledImageHeight > 0)
632                     sy = scaledImageHeight - bgLayer->backgroundYPosition().calcMinValue(ph - scaledImageHeight) % scaledImageHeight;
633             }
634
635             IntRect b = intersection(IntRect(cx, cy, cw, ch), IntRect(_tx, _ty, w, h));
636             sx += b.x() - cx;
637             sy += b.y() - cy;
638             cx = b.x();
639             cy = b.y();
640             cw = b.width();
641             ch = b.height();
642         }
643
644         if (cw > 0 && ch > 0)
645             p->drawTiledImage(bg->image(), IntRect(cx, cy, cw, ch), IntPoint(sx, sy), IntSize(scaledImageWidth, scaledImageHeight));
646     }
647     
648     if (bgLayer->backgroundClip() != BGBORDER)
649         p->restore(); // Undo the background clip
650         
651     if (clippedToBorderRadius)
652         p->restore(); // Undo the border radius clip
653 }
654
655 void RenderBox::outlineBox(GraphicsContext* p, int _tx, int _ty, const char* color)
656 {
657     p->setPen(Pen(Color(color), 1, Pen::DotLine));
658     p->setFillColor(Color::transparent);
659     p->drawRect(IntRect(_tx, _ty, m_width, m_height));
660 }
661
662 IntRect RenderBox::getOverflowClipRect(int tx, int ty)
663 {
664     // XXX When overflow-clip (CSS3) is implemented, we'll obtain the property
665     // here.
666     int bl=borderLeft(),bt=borderTop(),bb=borderBottom(),br=borderRight();
667     int clipx = tx + bl;
668     int clipy = ty + bt;
669     int clipw = m_width - bl - br;
670     int cliph = m_height - bt - bb + borderTopExtra() + borderBottomExtra();
671
672     // Subtract out scrollbars if we have them.
673     if (m_layer) {
674         clipw -= m_layer->verticalScrollbarWidth();
675         cliph -= m_layer->horizontalScrollbarHeight();
676     }
677     return IntRect(clipx,clipy,clipw,cliph);
678 }
679
680 IntRect RenderBox::getClipRect(int tx, int ty)
681 {
682     int clipx = tx;
683     int clipy = ty;
684     int clipw = m_width;
685     int cliph = m_height;
686
687     if (!style()->clipLeft().isAuto()) {
688         int c = style()->clipLeft().calcValue(m_width);
689         clipx += c;
690         clipw -= c;
691     }
692         
693     if (!style()->clipRight().isAuto()) {
694         int w = style()->clipRight().calcValue(m_width);
695         clipw -= m_width - w;
696     }
697     
698     if (!style()->clipTop().isAuto()) {
699         int c = style()->clipTop().calcValue(m_height);
700         clipy += c;
701         cliph -= c;
702     }
703
704     if (!style()->clipBottom().isAuto()) {
705         int h = style()->clipBottom().calcValue(m_height);
706         cliph -= m_height - h;
707     }
708
709     return IntRect(clipx, clipy, clipw, cliph);
710 }
711
712 int RenderBox::containingBlockWidth() const
713 {
714     RenderBlock* cb = containingBlock();
715     if (!cb)
716         return 0;
717     if (usesLineWidth())
718         return cb->lineWidth(m_y);
719     else
720         return cb->contentWidth();
721 }
722
723 bool RenderBox::absolutePosition(int &xPos, int &yPos, bool f)
724 {
725     if (style()->position() == FixedPosition)
726         f = true;
727     RenderObject *o = container();
728     if (o && o->absolutePosition(xPos, yPos, f)) {
729         yPos += o->borderTopExtra();
730         if (style()->position() == AbsolutePosition && o->isRelPositioned() && o->isInlineFlow()) {
731             // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
732             // box from the rest of the content, but only in the cases where we know we're positioned
733             // relative to the inline itself.
734             RenderFlow* flow = static_cast<RenderFlow*>(o);
735             int sx = 0;
736             int sy = 0;
737             if (flow->firstLineBox()) {
738                 sx = flow->firstLineBox()->xPos();
739                 sy = flow->firstLineBox()->yPos();
740             } else {
741                 sx = flow->staticX();
742                 sy = flow->staticY();
743             }
744             
745             bool isInlineType = style()->isOriginalDisplayInlineType();
746             
747             if (!hasStaticX())
748                 xPos += sx;
749             // This is not terribly intuitive, but we have to match other browsers.  Despite being a block display type inside
750             // an inline, we still keep our x locked to the left of the relative positioned inline.  Arguably the correct
751             // behavior would be to go flush left to the block that contains the inline, but that isn't what other browsers
752             // do.
753             if (hasStaticX() && !isInlineType)
754                 // Avoid adding in the left border/padding of the containing block twice.  Subtract it out.
755                 xPos += sx - (containingBlock()->borderLeft() + containingBlock()->paddingLeft());
756             
757             if (!hasStaticY())
758                 yPos += sy;
759         }
760         if (o->hasOverflowClip())
761             o->layer()->subtractScrollOffset(xPos, yPos); 
762             
763         if (!isInline() || isReplaced()) {
764             xPos += m_x;
765             yPos += m_y;
766         }
767
768         if (isRelPositioned()) {
769             xPos += relativePositionOffsetX();
770             yPos += relativePositionOffsetY();            
771         }
772
773         return true;
774     }
775     else {
776         xPos = yPos = 0;
777         return false;
778     }
779 }
780
781 void RenderBox::dirtyLineBoxes(bool fullLayout, bool)
782 {
783     if (m_inlineBoxWrapper) {
784         if (fullLayout) {
785             m_inlineBoxWrapper->destroy(renderArena());
786             m_inlineBoxWrapper = 0;
787         }
788         else
789             m_inlineBoxWrapper->dirtyLineBoxes();
790     }
791 }
792
793 void RenderBox::position(InlineBox* box, int from, int len, bool reverse, bool override)
794 {
795     if (isPositioned()) {
796         // Cache the x position only if we were an INLINE type originally.
797         bool wasInline = style()->isOriginalDisplayInlineType();
798         if (wasInline && hasStaticX()) {
799             // The value is cached in the xPos of the box.  We only need this value if
800             // our object was inline originally, since otherwise it would have ended up underneath
801             // the inlines.
802             m_staticX = box->xPos();
803         }
804         else if (!wasInline && hasStaticY())
805             // Our object was a block originally, so we make our normal flow position be
806             // just below the line box (as though all the inlines that came before us got
807             // wrapped in an anonymous block, which is what would have happened had we been
808             // in flow).  This value was cached in the yPos() of the box.
809             m_staticY = box->yPos();
810
811         // Nuke the box.
812         box->remove();
813         box->destroy(renderArena());
814     }
815     else if (isReplaced()) {
816         m_x = box->xPos();
817         m_y = box->yPos();
818         m_inlineBoxWrapper = box;
819     }
820 }
821
822 // For inline replaced elements, this function returns the inline box that owns us.  Enables
823 // the replaced RenderObject to quickly determine what line it is contained on and to easily
824 // iterate over structures on the line.
825 InlineBox* RenderBox::inlineBoxWrapper() const
826 {
827     return m_inlineBoxWrapper;
828 }
829
830 void RenderBox::deleteLineBoxWrapper()
831 {
832     if (m_inlineBoxWrapper) {
833         if (!documentBeingDestroyed())
834             m_inlineBoxWrapper->remove();
835         m_inlineBoxWrapper->destroy(renderArena());
836         m_inlineBoxWrapper = 0;
837     }
838 }
839
840 void RenderBox::setInlineBoxWrapper(InlineBox* b)
841 {
842     m_inlineBoxWrapper = b;
843 }
844
845 IntRect RenderBox::getAbsoluteRepaintRect()
846 {
847     IntRect r = overflowRect(false);
848     if (style()) {
849         if (style()->hasAppearance())
850             // The theme may wish to inflate the rect used when repainting.
851             theme()->adjustRepaintRect(this, r);
852         r.inflate(style()->outlineSize()); // FIXME: Technically the outline inflation could fit within the theme inflation.
853     }
854     computeAbsoluteRepaintRect(r);
855     return r;
856 }
857
858 void RenderBox::computeAbsoluteRepaintRect(IntRect& r, bool f)
859 {
860     int x = r.x() + m_x;
861     int y = r.y() + m_y;
862      
863     // Apply the relative position offset when invalidating a rectangle.  The layer
864     // is translated, but the render box isn't, so we need to do this to get the
865     // right dirty rect.  Since this is called from RenderObject::setStyle, the relative position
866     // flag on the RenderObject has been cleared, so use the one on the style().
867     if (style()->position() == RelativePosition && m_layer)
868         m_layer->relativePositionOffset(x,y);
869     
870     if (style()->position()==FixedPosition)
871         f = true;
872
873     RenderObject* o = container();
874     if (o) {
875         if (style()->position() == AbsolutePosition && o->isRelPositioned() && o->isInlineFlow()) {
876             // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
877             // box from the rest of the content, but only in the cases where we know we're positioned
878             // relative to the inline itself.
879             RenderFlow* flow = static_cast<RenderFlow*>(o);
880             int sx = 0;
881             int sy = 0;
882             if (flow->firstLineBox()) {
883                 sx = flow->firstLineBox()->xPos();
884                 sy = flow->firstLineBox()->yPos();
885             } else {
886                 sx = flow->staticX();
887                 sy = flow->staticY();
888             }
889             
890             bool isInlineType = style()->isOriginalDisplayInlineType();
891             
892             if (!hasStaticX())
893                 x += sx;
894             // This is not terribly intuitive, but we have to match other browsers.  Despite being a block display type inside
895             // an inline, we still keep our x locked to the left of the relative positioned inline.  Arguably the correct
896             // behavior would be to go flush left to the block that contains the inline, but that isn't what other browsers
897             // do.
898             if (hasStaticX() && !isInlineType)
899                 // Avoid adding in the left border/padding of the containing block twice.  Subtract it out.
900                 x += sx - (containingBlock()->borderLeft() + containingBlock()->paddingLeft());
901             
902             if (!hasStaticY())
903                 y += sy;
904         }
905         // <body> may not have overflow, since it might be applying its overflow value to the
906         // scrollbars.
907         if (o->hasOverflowClip()) {
908             // o->height() is inaccurate if we're in the middle of a layout of |o|, so use the
909             // layer's size instead.  Even if the layer's size is wrong, the layer itself will repaint
910             // anyway if its size does change.
911             IntRect boxRect(0, 0, o->layer()->width(), o->layer()->height());
912             o->layer()->subtractScrollOffset(x,y); // For overflow:auto/scroll/hidden.
913             IntRect repaintRect(x, y, r.width(), r.height());
914             r = intersection(repaintRect, boxRect);
915             if (r.isEmpty())
916                 return;
917         } else {
918             r.setX(x);
919             r.setY(y);
920         }
921         o->computeAbsoluteRepaintRect(r, f);
922     }
923 }
924
925 void RenderBox::repaintDuringLayoutIfMoved(int oldX, int oldY)
926 {
927     int newX = m_x;
928     int newY = m_y;
929     if (oldX != newX || oldY != newY) {
930         // The child moved.  Invalidate the object's old and new positions.  We have to do this
931         // since the object may not have gotten a layout.
932         m_x = oldX; m_y = oldY;
933         repaint();
934         repaintFloatingDescendants();
935         m_x = newX; m_y = newY;
936         repaint();
937         repaintFloatingDescendants();
938     }
939 }
940
941 int RenderBox::relativePositionOffsetX() const
942 {
943     int tx = 0;
944     if(!style()->left().isAuto())
945         tx = style()->left().calcValue(containingBlockWidth());
946     else if(!style()->right().isAuto())
947         tx = -style()->right().calcValue(containingBlockWidth());
948     return tx;
949 }
950
951 int RenderBox::relativePositionOffsetY() const
952 {
953     int ty = 0;
954     if(!style()->top().isAuto())
955     {
956         if (!style()->top().isPercent()
957                 || containingBlock()->style()->height().isFixed())
958             ty = style()->top().calcValue(containingBlockHeight());
959     }
960     else if(!style()->bottom().isAuto())
961     {
962         if (!style()->bottom().isPercent()
963                 || containingBlock()->style()->height().isFixed())
964             ty = -style()->bottom().calcValue(containingBlockHeight());
965     }
966     return ty;
967 }
968
969 void RenderBox::calcWidth()
970 {
971     if (isPositioned()) {
972         calcAbsoluteHorizontal();
973         return;
974     }
975     
976     // If layout is limited to a subtree, the subtree root's width does not change.
977     if (node() && view()->frameView() && view()->frameView()->layoutRoot() == node())
978         return;
979
980     // The parent box is flexing us, so it has increased or decreased our
981     // width.  Use the width from the style context.
982     if (m_overrideSize != -1 && parent()->style()->boxOrient() == HORIZONTAL
983             && parent()->isFlexibleBox() && parent()->isFlexingChildren()) {
984         m_width = m_overrideSize;
985         return;
986     }
987
988     bool inVerticalBox = parent()->isFlexibleBox() && (parent()->style()->boxOrient() == VERTICAL);
989     bool stretching = (parent()->style()->boxAlign() == BSTRETCH);
990     bool treatAsReplaced = isReplaced() && !isInlineBlockOrInlineTable() && (!inVerticalBox || !stretching);
991     
992     Length width = (treatAsReplaced) ? Length(calcReplacedWidth(), Fixed) : style()->width();
993     
994     RenderBlock* cb = containingBlock();
995     int containerWidth = max(0, containingBlockWidth());
996
997     Length marginLeft = style()->marginLeft();
998     Length marginRight = style()->marginRight();
999
1000     if (isInline() && !isInlineBlockOrInlineTable()) {
1001         // just calculate margins
1002         m_marginLeft = marginLeft.calcMinValue(containerWidth);
1003         m_marginRight = marginRight.calcMinValue(containerWidth);
1004         if (treatAsReplaced)
1005             m_width = max(width.value() + borderLeft() + borderRight() + paddingLeft() + paddingRight(), m_minWidth);
1006         
1007         return;
1008     }
1009
1010     // Width calculations
1011     if (treatAsReplaced)
1012         m_width = width.value() + borderLeft() + borderRight() + paddingLeft() + paddingRight();
1013     else {
1014         // Calculate Width
1015         m_width = calcWidthUsing(Width, containerWidth);
1016         
1017         // Calculate MaxWidth
1018         if (style()->maxWidth().value() != undefinedLength) {
1019             int maxW = calcWidthUsing(MaxWidth, containerWidth);
1020             if (m_width > maxW) {
1021                 m_width = maxW;
1022                 width = style()->maxWidth();
1023             }
1024         }
1025
1026         // Calculate MinWidth
1027         int minW = calcWidthUsing(MinWidth, containerWidth);        
1028         if (m_width < minW) {
1029             m_width = minW;
1030             width = style()->minWidth();
1031         }
1032     }
1033     
1034     // Margin calculations
1035     if (width.isAuto()) {
1036         m_marginLeft = marginLeft.calcMinValue(containerWidth);
1037         m_marginRight = marginRight.calcMinValue(containerWidth);
1038     } else {
1039         m_marginLeft = 0;
1040         m_marginRight = 0;
1041         calcHorizontalMargins(marginLeft, marginRight, containerWidth);
1042     }
1043     
1044     if (containerWidth && containerWidth != (m_width + m_marginLeft + m_marginRight)
1045             && !isFloating() && !isInline() && !cb->isFlexibleBox()) {
1046         if (cb->style()->direction() == LTR)
1047             m_marginRight = containerWidth - m_width - m_marginLeft;
1048         else
1049             m_marginLeft = containerWidth - m_width - m_marginRight;
1050     }
1051 }
1052
1053 int RenderBox::calcWidthUsing(WidthType widthType, int cw)
1054 {
1055     int width = m_width;
1056     Length w;
1057     if (widthType == Width)
1058         w = style()->width();
1059     else if (widthType == MinWidth)
1060         w = style()->minWidth();
1061     else
1062         w = style()->maxWidth();
1063
1064     if (w.isIntrinsicOrAuto()) {
1065         int marginLeft = style()->marginLeft().calcMinValue(cw);
1066         int marginRight = style()->marginRight().calcMinValue(cw);
1067         if (cw)
1068             width = cw - marginLeft - marginRight;
1069         
1070         if (sizesToIntrinsicWidth(widthType)) {
1071             width = max(width, m_minWidth);
1072             width = min(width, m_maxWidth);
1073         }
1074     } else
1075         width = calcBorderBoxWidth(w.calcValue(cw));
1076     
1077     return width;
1078 }
1079
1080 bool RenderBox::sizesToIntrinsicWidth(WidthType widthType) const
1081 {
1082     // Marquees in WinIE are like a mixture of blocks and inline-blocks.  They size as though they're blocks,
1083     // but they allow text to sit on the same line as the marquee.
1084     if (isFloating() || (isCompact() && isInline()) || 
1085         (isInlineBlockOrInlineTable() && !isHTMLMarquee()))
1086         return true;
1087     
1088     // This code may look a bit strange.  Basically width:intrinsic should clamp the size when testing both
1089     // min-width and width.  max-width is only clamped if it is also intrinsic.
1090     Length width = (widthType == MaxWidth) ? style()->maxWidth() : style()->width();
1091     if (width.type() == Intrinsic)
1092         return true;
1093     
1094     // Children of a horizontal marquee do not fill the container by default.
1095     // FIXME: Need to deal with MAUTO value properly.  It could be vertical.
1096     if (parent()->style()->overflowX() == OMARQUEE) {
1097         EMarqueeDirection dir = parent()->style()->marqueeDirection();
1098         if (dir == MAUTO || dir == MFORWARD || dir == MBACKWARD || dir == MLEFT || dir == MRIGHT)
1099             return true;
1100     }
1101     
1102     // Flexible horizontal boxes lay out children at their intrinsic widths.  Also vertical boxes
1103     // that don't stretch their kids lay out their children at their intrinsic widths.
1104     if (parent()->isFlexibleBox() &&
1105         (parent()->style()->boxOrient() == HORIZONTAL || parent()->style()->boxAlign() != BSTRETCH))
1106         return true;
1107
1108     return false;
1109 }
1110
1111 void RenderBox::calcHorizontalMargins(const Length& ml, const Length& mr, int cw)
1112 {
1113     if (isFloating() || isInline()) // Inline blocks/tables and floats don't have their margins increased.
1114     {
1115         m_marginLeft = ml.calcMinValue(cw);
1116         m_marginRight = mr.calcMinValue(cw);
1117     }
1118     else
1119     {
1120         if ( (ml.isAuto() && mr.isAuto() && m_width<cw) ||
1121              (!ml.isAuto() && !mr.isAuto() &&
1122                 containingBlock()->style()->textAlign() == KHTML_CENTER) )
1123         {
1124             m_marginLeft = (cw - m_width)/2;
1125             if (m_marginLeft<0) m_marginLeft=0;
1126             m_marginRight = cw - m_width - m_marginLeft;
1127         }
1128         else if ( (mr.isAuto() && m_width<cw) ||
1129                  (!ml.isAuto() && containingBlock()->style()->direction() == RTL &&
1130                   containingBlock()->style()->textAlign() == KHTML_LEFT))
1131         {
1132             m_marginLeft = ml.calcValue(cw);
1133             m_marginRight = cw - m_width - m_marginLeft;
1134         }
1135         else if ( (ml.isAuto() && m_width<cw) ||
1136                  (!mr.isAuto() && containingBlock()->style()->direction() == LTR &&
1137                   containingBlock()->style()->textAlign() == KHTML_RIGHT))
1138         {
1139             m_marginRight = mr.calcValue(cw);
1140             m_marginLeft = cw - m_width - m_marginRight;
1141         }
1142         else
1143         {
1144             // this makes auto margins 0 if we failed a m_width<cw test above (css2.1, 10.3.3)
1145             m_marginLeft = ml.calcMinValue(cw);
1146             m_marginRight = mr.calcMinValue(cw);
1147         }
1148     }
1149 }
1150
1151 void RenderBox::calcHeight()
1152 {
1153     // Cell height is managed by the table and inline non-replaced elements do not support a height property.
1154     if (isTableCell() || (isInline() && !isReplaced()))
1155         return;
1156
1157     if (isPositioned())
1158         calcAbsoluteVertical();
1159     else
1160     {
1161         calcVerticalMargins();
1162         
1163         // For tables, calculate margins only
1164         if (isTable())
1165             return;
1166         
1167         Length h;
1168         bool inHorizontalBox = parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL;
1169         bool stretching = parent()->style()->boxAlign() == BSTRETCH;
1170         bool treatAsReplaced = isReplaced() && !isInlineBlockOrInlineTable() && (!inHorizontalBox || !stretching);
1171         bool checkMinMaxHeight = false;
1172         
1173         // The parent box is flexing us, so it has increased or decreased our height.  We have to
1174         // grab our cached flexible height.
1175         if (m_overrideSize != -1 && parent()->isFlexibleBox() && parent()->style()->boxOrient() == VERTICAL
1176             && parent()->isFlexingChildren())
1177             h = Length(m_overrideSize - borderTop() - borderBottom() - paddingTop() - paddingBottom(), Fixed);
1178         else if (treatAsReplaced)
1179             h = Length(calcReplacedHeight(), Fixed);
1180         else {
1181             h = style()->height();
1182             checkMinMaxHeight = true;
1183         }
1184         
1185         // Block children of horizontal flexible boxes fill the height of the box.
1186         if (h.isAuto() && parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL
1187             && parent()->isStretchingChildren()) {
1188             h = Length(parent()->contentHeight() - marginTop() - marginBottom() -
1189                        borderTop() - paddingTop() - borderBottom() - paddingBottom(), Fixed);
1190             checkMinMaxHeight = false;
1191         }
1192
1193         int height;
1194         if (checkMinMaxHeight) {
1195             height = calcHeightUsing(style()->height());
1196             if (height == -1)
1197                 height = m_height;
1198             int minH = calcHeightUsing(style()->minHeight()); // Leave as -1 if unset.
1199             int maxH = style()->maxHeight().value() == undefinedLength ? height : calcHeightUsing(style()->maxHeight());
1200             if (maxH == -1)
1201                 maxH = height;
1202             height = min(maxH, height);
1203             height = max(minH, height);
1204         }
1205         else
1206             // The only times we don't check min/max height are when a fixed length has 
1207             // been given as an override.  Just use that.  The value has already been adjusted
1208             // for box-sizing.
1209             height = h.value() + borderTop() + borderBottom() + paddingTop() + paddingBottom();
1210
1211         m_height = height;
1212     }
1213     
1214     // Unfurling marquees override with the furled height.
1215     if (style()->overflowX() == OMARQUEE && m_layer && m_layer->marquee() && 
1216         m_layer->marquee()->isUnfurlMarquee() && !m_layer->marquee()->isHorizontal()) {
1217         m_layer->marquee()->setEnd(m_height);
1218         m_height = min(m_height, m_layer->marquee()->unfurlPos());
1219     }
1220     
1221     // WinIE quirk: The <html> block always fills the entire canvas in quirks mode.  The <body> always fills the
1222     // <html> block in quirks mode.  Only apply this quirk if the block is normal flow and no height
1223     // is specified.
1224     if (stretchesToViewHeight()) {
1225         int margins = collapsedMarginTop() + collapsedMarginBottom();
1226         int visHeight = view()->frameView()->visibleHeight();
1227         if (isRoot())
1228             m_height = max(m_height, visHeight - margins);
1229         else
1230             m_height = max(m_height, visHeight - 
1231                             (margins + parent()->marginTop() + parent()->marginBottom() + 
1232                              parent()->borderTop() + parent()->borderBottom() +
1233                              parent()->paddingTop() + parent()->paddingBottom()));
1234     }
1235 }
1236
1237 int RenderBox::calcHeightUsing(const Length& h)
1238 {
1239     int height = -1;
1240     if (!h.isAuto()) {
1241         if (h.isFixed())
1242             height = h.value();
1243         else if (h.isPercent())
1244             height = calcPercentageHeight(h);
1245         if (height != -1) {
1246             height = calcBorderBoxHeight(height);
1247             return height;
1248         }
1249     }
1250     return height;
1251 }
1252
1253 int RenderBox::calcPercentageHeight(const Length& height)
1254 {
1255     int result = -1;
1256     bool includeBorderPadding = isTable();
1257     RenderBlock* cb = containingBlock();
1258     if (style()->htmlHacks()) {
1259         // In quirks mode, blocks with auto height are skipped, and we keep looking for an enclosing
1260         // block that may have a specified height and then use it.  In strict mode, this violates the
1261         // specification, which states that percentage heights just revert to auto if the containing
1262         // block has an auto height.
1263         for ( ; !cb->isRenderView() && !cb->isBody() && !cb->isTableCell() && !cb->isPositioned() &&
1264                 cb->style()->height().isAuto(); cb = cb->containingBlock());
1265     }
1266
1267     // Table cells violate what the CSS spec says to do with heights.  Basically we
1268     // don't care if the cell specified a height or not.  We just always make ourselves
1269     // be a percentage of the cell's current content height.
1270     if (cb->isTableCell()) {
1271         result = cb->overrideSize();
1272         if (result == -1) {
1273             // Normally we would let the cell size intrinsically, but scrolling overflow has to be
1274             // treated differently, since WinIE lets scrolled overflow regions shrink as needed.
1275             // While we can't get all cases right, we can at least detect when the cell has a specified
1276             // height or when the table has a specified height.  In these cases we want to initially have
1277             // no size and allow the flexing of the table or the cell to its specified height to cause us
1278             // to grow to fill the space.  This could end up being wrong in some cases, but it is
1279             // preferable to the alternative (sizing intrinsically and making the row end up too big).
1280             RenderTableCell* cell = static_cast<RenderTableCell*>(cb);
1281             if (scrollsOverflowY() && (!cell->style()->height().isAuto() || !cell->table()->style()->height().isAuto()))
1282                 return 0;
1283             return -1;
1284         }
1285         includeBorderPadding = true;
1286     }
1287
1288     // Otherwise we only use our percentage height if our containing block had a specified
1289     // height.
1290     else if (cb->style()->height().isFixed())
1291         result = cb->calcContentBoxHeight(cb->style()->height().value());
1292     else if (cb->style()->height().isPercent()) {
1293         // We need to recur and compute the percentage height for our containing block.
1294         result = cb->calcPercentageHeight(cb->style()->height());
1295         if (result != -1)
1296             result = cb->calcContentBoxHeight(result);
1297     } else if (cb->isRenderView() || (cb->isBody() && style()->htmlHacks()) ||
1298                (cb->isPositioned() && !(cb->style()->top().isAuto() || cb->style()->bottom().isAuto()))) {
1299         // Don't allow this to affect the block' m_height member variable, since this
1300         // can get called while the block is still laying out its kids.
1301         int oldHeight = cb->height();
1302         cb->calcHeight();
1303         result = cb->contentHeight();
1304         cb->setHeight(oldHeight);
1305     } else if (cb->isRoot() && isPositioned())
1306         // Match the positioned objects behavior, which is that positioned objects will fill their viewport
1307         // always.  Note we could only hit this case by recurring into calcPercentageHeight on a positioned containing block.
1308         result = cb->calcContentBoxHeight(cb->availableHeight());
1309
1310     if (result != -1) {
1311         result = height.calcValue(result);
1312         if (includeBorderPadding) {
1313             // It is necessary to use the border-box to match WinIE's broken
1314             // box model.  This is essential for sizing inside
1315             // table cells using percentage heights.
1316             result -= (borderTop() + paddingTop() + borderBottom() + paddingBottom());
1317             result = max(0, result);
1318         }
1319     }
1320     return result;
1321 }
1322
1323 int RenderBox::calcReplacedWidth() const
1324 {
1325     int width = calcReplacedWidthUsing(style()->width());
1326     int minW = calcReplacedWidthUsing(style()->minWidth());
1327     int maxW = style()->maxWidth().value() == undefinedLength ? width : calcReplacedWidthUsing(style()->maxWidth());
1328
1329     return max(minW, min(width, maxW));
1330 }
1331
1332 int RenderBox::calcReplacedWidthUsing(Length width) const
1333 {    
1334     switch (width.type()) {
1335         case Fixed:
1336             return calcContentBoxWidth(width.value());
1337         case Percent: {
1338             const int cw = containingBlockWidth();
1339             if (cw > 0)
1340                 return calcContentBoxWidth(width.calcMinValue(cw));
1341         }
1342         // fall through
1343         default:
1344             return intrinsicWidth();
1345      }
1346  }
1347
1348 int RenderBox::calcReplacedHeight() const
1349 {
1350     int height = calcReplacedHeightUsing(style()->height());
1351     int minH = calcReplacedHeightUsing(style()->minHeight());
1352     int maxH = style()->maxHeight().value() == undefinedLength ? height : calcReplacedHeightUsing(style()->maxHeight());
1353
1354     return max(minH, min(height, maxH));
1355 }
1356
1357 int RenderBox::calcReplacedHeightUsing(Length height) const
1358 {
1359     switch (height.type()) {
1360         case Fixed:
1361             return calcContentBoxHeight(height.value());
1362         case Percent:
1363         {
1364             RenderBlock* cb = containingBlock();
1365             if (cb->isPositioned() && cb->style()->height().isAuto() && !(cb->style()->top().isAuto() || cb->style()->bottom().isAuto())) {
1366                 int oldHeight = cb->height();
1367                 cb->calcHeight();
1368                 int newHeight = cb->calcContentBoxHeight(cb->contentHeight());
1369                 cb->setHeight(oldHeight);
1370         
1371                 return calcContentBoxHeight(height.calcValue(newHeight));
1372             }
1373
1374             return calcContentBoxHeight(height.calcValue(cb->availableHeight()));
1375         }
1376         default:
1377             return intrinsicHeight();
1378     }
1379 }
1380
1381 int RenderBox::availableHeight() const
1382 {
1383     return availableHeightUsing(style()->height());
1384 }
1385
1386 int RenderBox::availableHeightUsing(const Length& h) const
1387 {
1388     if (h.isFixed())
1389         return calcContentBoxHeight(h.value());
1390
1391     if (isRenderView())
1392         return static_cast<const RenderView*>(this)->frameView()->visibleHeight();
1393
1394     // We need to stop here, since we don't want to increase the height of the table
1395     // artificially.  We're going to rely on this cell getting expanded to some new
1396     // height, and then when we lay out again we'll use the calculation below.
1397     if (isTableCell() && (h.isAuto() || h.isPercent()))
1398         return overrideSize() - (borderLeft() + borderRight() + paddingLeft() + paddingRight());
1399     
1400     if (h.isPercent())
1401        return calcContentBoxHeight(h.calcValue(containingBlock()->availableHeight()));
1402        
1403     return containingBlock()->availableHeight();
1404 }
1405
1406 void RenderBox::calcVerticalMargins()
1407 {
1408     if( isTableCell() ) {
1409         // table margins are basically infinite
1410         m_marginTop = TABLECELLMARGIN;
1411         m_marginBottom = TABLECELLMARGIN;
1412         return;
1413     }
1414
1415     Length tm = style()->marginTop();
1416     Length bm = style()->marginBottom();
1417
1418     // margins are calculated with respect to the _width_ of
1419     // the containing block (8.3)
1420     int cw = containingBlock()->contentWidth();
1421
1422     m_marginTop = tm.calcMinValue(cw);
1423     m_marginBottom = bm.calcMinValue(cw);
1424 }
1425
1426 void RenderBox::setStaticX(int staticX)
1427 {
1428     m_staticX = staticX;
1429 }
1430
1431 void RenderBox::setStaticY(int staticY)
1432 {
1433     m_staticY = staticY;
1434 }
1435
1436 int RenderBox::containingBlockWidthForPositioned(const RenderObject* containingBlock) const
1437 {
1438     if (containingBlock->isInline()) {
1439         ASSERT(containingBlock->isRelPositioned());
1440     
1441         const RenderFlow* flow = static_cast<const RenderFlow*>(containingBlock);
1442         InlineFlowBox* first = flow->firstLineBox();
1443         InlineFlowBox* last = flow->lastLineBox();
1444         
1445         // If the containing block is empty, return a width of 0.
1446         if (!first || !last)
1447             return 0;
1448
1449         int fromLeft;
1450         int fromRight;
1451         if (containingBlock->style()->direction() == LTR) {
1452             fromLeft = first->xPos() + first->borderLeft();
1453             fromRight = last->xPos() + last->width() - last->borderRight();
1454         } else {
1455             fromRight = first->xPos() + first->width() - first->borderRight();
1456             fromLeft = last->xPos() + last->borderLeft();
1457         }
1458
1459         return max(0, (fromRight - fromLeft));
1460     }
1461
1462     if (usesLineWidth() && isRenderBlock())
1463         return static_cast<const RenderBlock*>(containingBlock)->lineWidth(m_y) + containingBlock->paddingLeft() + containingBlock->paddingRight();
1464     return containingBlock->width() - containingBlock->borderLeft() - containingBlock->borderRight();
1465 }
1466
1467 int RenderBox::containingBlockHeightForPositioned(const RenderObject* containingBlock) const
1468 {
1469     // Even in strict mode (where we don't grow the root to fill the viewport) other browsers
1470     // position as though the root fills the viewport.
1471     if (containingBlock->isRoot())
1472         return containingBlock->availableHeight();
1473     return containingBlock->height() - containingBlock->borderTop() - containingBlock->borderBottom();
1474 }
1475
1476 void RenderBox::calcAbsoluteHorizontal()
1477 {
1478     if (isReplaced()) {
1479         calcAbsoluteHorizontalReplaced();
1480         return; 
1481     }
1482
1483
1484     // QUESTIONS
1485     // FIXME 1: Which RenderObject's 'direction' property should used: the
1486     // containing block (cb) as the spec seems to imply, the parent (parent()) as
1487     // was previously done in calculating the static distances, or ourself, which
1488     // was also previously done for deciding what to override when you had
1489     // over-constrained margins?  Also note that the container block is used
1490     // in similar situations in other parts of the RenderBox class (see calcWidth()
1491     // and calcHorizontalMargins()). For now we are using the parent for quirks
1492     // mode and the containing block for strict mode.
1493
1494     // FIXME 2: Should we still deal with these the cases of 'left' or 'right' having
1495     // the type 'static' in determining whether to calculate the static distance?
1496     // NOTE: 'static' is not a legal value for 'left' or 'right' as of CSS 2.1.
1497
1498     // FIXME 3: Can perhaps optimize out cases when max-width/min-width are greater
1499     // than or less than the computed m_width.  Be careful of box-sizing and
1500     // percentage issues.
1501
1502     // The following is based off of the W3C Working Draft from April 11, 2006 of
1503     // CSS 2.1: Section 10.3.7 "Absolutely positioned, non-replaced elements"
1504     // <http://www.w3.org/TR/CSS21/visudet.html#abs-non-replaced-width>
1505     // (block-style-comments in this function and in calcAbsoluteHorizontalValues()
1506     // correspond to text from the spec)
1507
1508
1509     // We don't use containingBlock(), since we may be positioned by an enclosing
1510     // relative positioned inline.
1511     const RenderObject* containerBlock = container();
1512
1513     const int containerWidth = containingBlockWidthForPositioned(containerBlock);
1514
1515     // To match WinIE, in quirks mode use the parent's 'direction' property
1516     // instead of the the container block's.
1517     TextDirection containerDirection = (style()->htmlHacks()) ? parent()->style()->direction() : containerBlock->style()->direction();
1518
1519     const int bordersPlusPadding = borderLeft() + borderRight() + paddingLeft() + paddingRight();
1520     const Length marginLeft = style()->marginLeft();
1521     const Length marginRight = style()->marginRight();
1522     Length left = style()->left();
1523     Length right = style()->right();
1524
1525     /*---------------------------------------------------------------------------*\
1526      * For the purposes of this section and the next, the term "static position"
1527      * (of an element) refers, roughly, to the position an element would have had
1528      * in the normal flow. More precisely:
1529      *
1530      * * The static position for 'left' is the distance from the left edge of the
1531      *   containing block to the left margin edge of a hypothetical box that would
1532      *   have been the first box of the element if its 'position' property had
1533      *   been 'static' and 'float' had been 'none'. The value is negative if the
1534      *   hypothetical box is to the left of the containing block.
1535      * * The static position for 'right' is the distance from the right edge of the
1536      *   containing block to the right margin edge of the same hypothetical box as
1537      *   above. The value is positive if the hypothetical box is to the left of the
1538      *   containing block's edge.
1539      *
1540      * But rather than actually calculating the dimensions of that hypothetical box,
1541      * user agents are free to make a guess at its probable position.
1542      *
1543      * For the purposes of calculating the static position, the containing block of
1544      * fixed positioned elements is the initial containing block instead of the
1545      * viewport, and all scrollable boxes should be assumed to be scrolled to their
1546      * origin.
1547     \*---------------------------------------------------------------------------*/
1548
1549     // see FIXME 2
1550     // Calculate the static distance if needed.
1551     if (left.isAuto() && right.isAuto()) {
1552         if (containerDirection == LTR) {
1553             // 'm_staticX' should already have been set through layout of the parent.
1554             int staticPosition = m_staticX - containerBlock->borderLeft();
1555             for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent())
1556                 staticPosition += po->xPos();
1557             left.setValue(Fixed, staticPosition);
1558         } else {
1559             RenderObject* po = parent();
1560             // 'm_staticX' should already have been set through layout of the parent.
1561             int staticPosition = m_staticX + containerWidth + containerBlock->borderRight() - po->width();
1562             for (; po && po != containerBlock; po = po->parent())
1563                 staticPosition -= po->xPos();
1564             right.setValue(Fixed, staticPosition);
1565         }
1566     }
1567
1568     // Calculate constraint equation values for 'width' case.
1569     calcAbsoluteHorizontalValues(style()->width(), containerBlock, containerDirection,
1570                                  containerWidth, bordersPlusPadding,
1571                                  left, right, marginLeft, marginRight,
1572                                  m_width, m_marginLeft, m_marginRight, m_x);
1573
1574     // Calculate constraint equation values for 'max-width' case.calcContentBoxWidth(width.calcValue(containerWidth));
1575     if (style()->maxWidth().value() != undefinedLength) {
1576         int maxWidth;
1577         int maxMarginLeft;
1578         int maxMarginRight;
1579         int maxXPos;
1580
1581         calcAbsoluteHorizontalValues(style()->maxWidth(), containerBlock, containerDirection,
1582                                      containerWidth, bordersPlusPadding,
1583                                      left, right, marginLeft, marginRight,
1584                                      maxWidth, maxMarginLeft, maxMarginRight, maxXPos);
1585
1586         if (m_width > maxWidth) {
1587             m_width = maxWidth;
1588             m_marginLeft = maxMarginLeft;
1589             m_marginRight = maxMarginRight;
1590             m_x = maxXPos;
1591         }
1592     }
1593
1594     // Calculate constraint equation values for 'min-width' case.
1595     if (style()->minWidth().value()) {
1596         int minWidth;
1597         int minMarginLeft;
1598         int minMarginRight;
1599         int minXPos;
1600
1601         calcAbsoluteHorizontalValues(style()->minWidth(), containerBlock, containerDirection, 
1602                                      containerWidth, bordersPlusPadding,
1603                                      left, right, marginLeft, marginRight,
1604                                      minWidth, minMarginLeft, minMarginRight, minXPos);
1605
1606         if (m_width < minWidth) {
1607             m_width = minWidth;
1608             m_marginLeft = minMarginLeft;
1609             m_marginRight = minMarginRight;
1610             m_x = minXPos;
1611         }
1612     }
1613
1614     // Put m_width into correct form.
1615     m_width += bordersPlusPadding;
1616 }
1617
1618 void RenderBox::calcAbsoluteHorizontalValues(Length width, const RenderObject* containerBlock, TextDirection containerDirection,
1619                                              const int containerWidth, const int bordersPlusPadding,
1620                                              const Length left, const Length right, const Length marginLeft, const Length marginRight,
1621                                              int& widthValue, int& marginLeftValue, int& marginRightValue, int& xPos)
1622 {
1623     // 'left' and 'right' cannot both be 'auto' because one would of been
1624     // converted to the static postion already
1625     ASSERT(!(left.isAuto() && right.isAuto()));
1626
1627     int leftValue = 0;
1628
1629     bool widthIsAuto = width.isIntrinsicOrAuto();
1630     bool leftIsAuto = left.isAuto();
1631     bool rightIsAuto = right.isAuto();
1632
1633     if (!leftIsAuto && !widthIsAuto && !rightIsAuto) {
1634         /*-----------------------------------------------------------------------*\
1635          * If none of the three is 'auto': If both 'margin-left' and 'margin-
1636          * right' are 'auto', solve the equation under the extra constraint that
1637          * the two margins get equal values, unless this would make them negative,
1638          * in which case when direction of the containing block is 'ltr' ('rtl'),
1639          * set 'margin-left' ('margin-right') to zero and solve for 'margin-right'
1640          * ('margin-left'). If one of 'margin-left' or 'margin-right' is 'auto',
1641          * solve the equation for that value. If the values are over-constrained,
1642          * ignore the value for 'left' (in case the 'direction' property of the
1643          * containing block is 'rtl') or 'right' (in case 'direction' is 'ltr')
1644          * and solve for that value.
1645         \*-----------------------------------------------------------------------*/
1646         // NOTE:  It is not necessary to solve for 'right' in the over constrained
1647         // case because the value is not used for any further calculations.
1648
1649         leftValue = left.calcValue(containerWidth);
1650         widthValue = calcContentBoxWidth(width.calcValue(containerWidth));
1651
1652         const int availableSpace = containerWidth - (leftValue + widthValue + right.calcValue(containerWidth) + bordersPlusPadding);
1653
1654         // Margins are now the only unknown
1655         if (marginLeft.isAuto() && marginRight.isAuto()) {
1656             // Both margins auto, solve for equality
1657             if (availableSpace >= 0) {
1658                 marginLeftValue = availableSpace / 2; // split the diference
1659                 marginRightValue = availableSpace - marginLeftValue;  // account for odd valued differences
1660             } else {
1661                 // see FIXME 1
1662                 if (containerDirection == LTR) {
1663                     marginLeftValue = 0;
1664                     marginRightValue = availableSpace; // will be negative
1665                 } else {
1666                     marginLeftValue = availableSpace; // will be negative
1667                     marginRightValue = 0;
1668                 }
1669             }
1670         } else if (marginLeft.isAuto()) {
1671             // Solve for left margin
1672             marginRightValue = marginRight.calcValue(containerWidth);
1673             marginLeftValue = availableSpace - marginRightValue;
1674         } else if (marginRight.isAuto()) {
1675             // Solve for right margin
1676             marginLeftValue = marginLeft.calcValue(containerWidth);
1677             marginRightValue = availableSpace - marginLeftValue;
1678         } else {
1679             // Over-constrained, solve for left if direction is RTL
1680             marginLeftValue = marginLeft.calcValue(containerWidth);
1681             marginRightValue = marginRight.calcValue(containerWidth);
1682
1683             // see FIXME 1 -- used to be "this->style()->direction()"
1684             if (containerDirection == RTL)
1685                 leftValue = (availableSpace + leftValue) - marginLeftValue - marginRightValue;
1686         }
1687     } else {
1688         /*--------------------------------------------------------------------*\
1689          * Otherwise, set 'auto' values for 'margin-left' and 'margin-right'
1690          * to 0, and pick the one of the following six rules that applies.
1691          *
1692          * 1. 'left' and 'width' are 'auto' and 'right' is not 'auto', then the
1693          *    width is shrink-to-fit. Then solve for 'left'
1694          *
1695          *              OMIT RULE 2 AS IT SHOULD NEVER BE HIT
1696          * ------------------------------------------------------------------
1697          * 2. 'left' and 'right' are 'auto' and 'width' is not 'auto', then if
1698          *    the 'direction' property of the containing block is 'ltr' set
1699          *    'left' to the static position, otherwise set 'right' to the
1700          *    static position. Then solve for 'left' (if 'direction is 'rtl')
1701          *    or 'right' (if 'direction' is 'ltr').
1702          * ------------------------------------------------------------------
1703          *
1704          * 3. 'width' and 'right' are 'auto' and 'left' is not 'auto', then the
1705          *    width is shrink-to-fit . Then solve for 'right'
1706          * 4. 'left' is 'auto', 'width' and 'right' are not 'auto', then solve
1707          *    for 'left'
1708          * 5. 'width' is 'auto', 'left' and 'right' are not 'auto', then solve
1709          *    for 'width'
1710          * 6. 'right' is 'auto', 'left' and 'width' are not 'auto', then solve
1711          *    for 'right'
1712          *
1713          * Calculation of the shrink-to-fit width is similar to calculating the
1714          * width of a table cell using the automatic table layout algorithm.
1715          * Roughly: calculate the preferred width by formatting the content
1716          * without breaking lines other than where explicit line breaks occur,
1717          * and also calculate the preferred minimum width, e.g., by trying all
1718          * possible line breaks. CSS 2.1 does not define the exact algorithm.
1719          * Thirdly, calculate the available width: this is found by solving
1720          * for 'width' after setting 'left' (in case 1) or 'right' (in case 3)
1721          * to 0.
1722          *
1723          * Then the shrink-to-fit width is:
1724          * min(max(preferred minimum width, available width), preferred width).
1725         \*--------------------------------------------------------------------*/
1726         // NOTE: For rules 3 and 6 it is not necessary to solve for 'right'
1727         // because the value is not used for any further calculations.
1728
1729         // Calculate margins, 'auto' margins are ignored.
1730         marginLeftValue = marginLeft.calcMinValue(containerWidth);
1731         marginRightValue = marginRight.calcMinValue(containerWidth);
1732
1733         const int availableSpace = containerWidth - (marginLeftValue + marginRightValue + bordersPlusPadding);
1734
1735         // FIXME: Is there a faster way to find the correct case?
1736         // Use rule/case that applies.
1737         if (leftIsAuto && widthIsAuto && !rightIsAuto) {
1738             // RULE 1: (use shrink-to-fit for width, and solve of left)
1739             int rightValue = right.calcValue(containerWidth);
1740
1741             // FIXME: would it be better to have shrink-to-fit in one step?
1742             int preferredWidth = m_maxWidth - bordersPlusPadding;
1743             int preferredMinWidth = m_minWidth - bordersPlusPadding;
1744             int availableWidth = availableSpace - rightValue;
1745             widthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);
1746             leftValue = availableSpace - (widthValue + rightValue);
1747         } else if (!leftIsAuto && widthIsAuto && rightIsAuto) {
1748             // RULE 3: (use shrink-to-fit for width, and no need solve of right)
1749             leftValue = left.calcValue(containerWidth);
1750
1751             // FIXME: would it be better to have shrink-to-fit in one step?
1752             int preferredWidth = m_maxWidth - bordersPlusPadding;
1753             int preferredMinWidth = m_minWidth - bordersPlusPadding;
1754             int availableWidth = availableSpace - leftValue;
1755             widthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);
1756         } else if (leftIsAuto && !width.isAuto() && !rightIsAuto) {
1757             // RULE 4: (solve for left)
1758             widthValue = calcContentBoxWidth(width.calcValue(containerWidth));
1759             leftValue = availableSpace - (widthValue + right.calcValue(containerWidth));
1760         } else if (!leftIsAuto && widthIsAuto && !rightIsAuto) {
1761             // RULE 5: (solve for width)
1762             leftValue = left.calcValue(containerWidth);
1763             widthValue = availableSpace - (leftValue + right.calcValue(containerWidth));
1764         } else if (!leftIsAuto&& !widthIsAuto && rightIsAuto) {
1765             // RULE 6: (no need solve for right)
1766             leftValue = left.calcValue(containerWidth);
1767             widthValue = calcContentBoxWidth(width.calcValue(containerWidth));
1768         }
1769     }
1770
1771     // Use computed values to calculate the horizontal position.
1772
1773     // FIXME: This hack is needed to calculate the xPos for a 'rtl' relatively 
1774     // positioned, inline containing block because right now, it is using the xPos 
1775     // of the first line box when really it should use the last line box.  When 
1776     // this is fixed elsewhere, this block should be removed.
1777     if (containerBlock->isInline() && containerBlock->style()->direction() == RTL) {
1778         const RenderFlow* flow = static_cast<const RenderFlow*>(containerBlock);
1779         InlineFlowBox* firstLine = flow->firstLineBox();
1780         InlineFlowBox* lastLine = flow->lastLineBox();
1781         if (firstLine && lastLine && firstLine != lastLine) {
1782             xPos = leftValue + marginLeftValue + lastLine->borderLeft() + (lastLine->xPos() - firstLine->xPos());
1783             return;
1784         }
1785     }
1786
1787     xPos = leftValue + marginLeftValue + containerBlock->borderLeft();
1788 }
1789
1790 void RenderBox::calcAbsoluteVertical()
1791 {
1792     if (isReplaced()) {
1793         calcAbsoluteVerticalReplaced();
1794         return;
1795     }
1796
1797     // The following is based off of the W3C Working Draft from April 11, 2006 of
1798     // CSS 2.1: Section 10.6.4 "Absolutely positioned, non-replaced elements"
1799     // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-non-replaced-height>
1800     // (block-style-comments in this function and in calcAbsoluteVerticalValues()
1801     // correspond to text from the spec)
1802
1803
1804     // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline.
1805     const RenderObject* containerBlock = container();
1806
1807     const int containerHeight = containingBlockHeightForPositioned(containerBlock);
1808     
1809     const int bordersPlusPadding = borderTop() + borderBottom() + paddingTop() + paddingBottom();
1810     const Length marginTop = style()->marginTop();
1811     const Length marginBottom = style()->marginBottom();
1812     Length top = style()->top();
1813     Length bottom = style()->bottom();
1814
1815     /*---------------------------------------------------------------------------*\
1816      * For the purposes of this section and the next, the term "static position"
1817      * (of an element) refers, roughly, to the position an element would have had
1818      * in the normal flow. More precisely, the static position for 'top' is the
1819      * distance from the top edge of the containing block to the top margin edge
1820      * of a hypothetical box that would have been the first box of the element if
1821      * its 'position' property had been 'static' and 'float' had been 'none'. The
1822      * value is negative if the hypothetical box is above the containing block.
1823      *
1824      * But rather than actually calculating the dimensions of that hypothetical
1825      * box, user agents are free to make a guess at its probable position.
1826      *
1827      * For the purposes of calculating the static position, the containing block
1828      * of fixed positioned elements is the initial containing block instead of
1829      * the viewport.
1830     \*---------------------------------------------------------------------------*/
1831
1832     // see FIXME 2
1833     // Calculate the static distance if needed.
1834     if (top.isAuto() && bottom.isAuto()) {
1835         // m_staticY should already have been set through layout of the parent()
1836         int staticTop = m_staticY - containerBlock->borderTop();
1837         for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) {
1838             if (!po->isTableRow())
1839                 staticTop += po->yPos();
1840         }
1841         top.setValue(Fixed, staticTop);
1842     }
1843
1844
1845     int height; // Needed to compute overflow.
1846
1847     // Calculate constraint equation values for 'height' case.
1848     calcAbsoluteVerticalValues(style()->height(), containerBlock, containerHeight, bordersPlusPadding,
1849                                top, bottom, marginTop, marginBottom,
1850                                height, m_marginTop, m_marginBottom, m_y);
1851
1852     // Avoid doing any work in the common case (where the values of min-height and max-height are their defaults).    
1853     // see FIXME 3
1854
1855     // Calculate constraint equation values for 'max-height' case.
1856     if (style()->maxHeight().value() != undefinedLength) {
1857         int maxHeight;
1858         int maxMarginTop;
1859         int maxMarginBottom;
1860         int maxYPos;
1861
1862         calcAbsoluteVerticalValues(style()->maxHeight(), containerBlock, containerHeight, bordersPlusPadding,
1863                                    top, bottom, marginTop, marginBottom,
1864                                    maxHeight, maxMarginTop, maxMarginBottom, maxYPos);
1865
1866         if (height > maxHeight) {
1867             height = maxHeight;
1868             m_marginTop = maxMarginTop;
1869             m_marginBottom = maxMarginBottom;
1870             m_y = maxYPos;
1871         }
1872     }
1873
1874     // Calculate constraint equation values for 'min-height' case.
1875     if (style()->minHeight().value()) {
1876         int minHeight;
1877         int minMarginTop;
1878         int minMarginBottom;
1879         int minYPos;
1880
1881         calcAbsoluteVerticalValues(style()->minHeight(), containerBlock, containerHeight, bordersPlusPadding,
1882                                    top, bottom, marginTop, marginBottom,
1883                                    minHeight, minMarginTop, minMarginBottom, minYPos);
1884
1885         if (height < minHeight) {
1886             height = minHeight;
1887             m_marginTop = minMarginTop;
1888             m_marginBottom = minMarginBottom;
1889             m_y = minYPos;
1890         }
1891     }
1892
1893     height += bordersPlusPadding;
1894
1895     // If our natural/content height exceeds the new height once we've set it, then we
1896     // need to make sure to update overflow to track the spillout.
1897     if (m_height > height)
1898         setOverflowHeight(m_height);
1899
1900     // Set final height value.
1901     m_height = height;
1902 }
1903
1904 void RenderBox::calcAbsoluteVerticalValues(Length height, const RenderObject* containerBlock,
1905                                            const int containerHeight, const int bordersPlusPadding,
1906                                            const Length top, const Length bottom, const Length marginTop, const Length marginBottom,
1907                                            int& heightValue, int& marginTopValue, int& marginBottomValue, int& yPos)
1908 {
1909     // 'top' and 'bottom' cannot both be 'auto' because 'top would of been
1910     // converted to the static position in calcAbsoluteVertical()
1911     ASSERT(!(top.isAuto() && bottom.isAuto()));
1912
1913     int contentHeight = m_height - bordersPlusPadding;    
1914
1915     int topValue = 0;
1916
1917     bool heightIsAuto = height.isAuto();
1918     bool topIsAuto = top.isAuto();
1919     bool bottomIsAuto = bottom.isAuto();
1920
1921     // Height is never unsolved for tables.
1922     if (isTable() && heightIsAuto) {
1923         height.setValue(Fixed, contentHeight);
1924         heightIsAuto = false;
1925     }
1926
1927     if (!topIsAuto && !heightIsAuto && !bottomIsAuto) {
1928         /*-----------------------------------------------------------------------*\
1929          * If none of the three are 'auto': If both 'margin-top' and 'margin-
1930          * bottom' are 'auto', solve the equation under the extra constraint that
1931          * the two margins get equal values. If one of 'margin-top' or 'margin-
1932          * bottom' is 'auto', solve the equation for that value. If the values
1933          * are over-constrained, ignore the value for 'bottom' and solve for that
1934          * value.
1935         \*-----------------------------------------------------------------------*/
1936         // NOTE:  It is not necessary to solve for 'bottom' in the over constrained
1937         // case because the value is not used for any further calculations.
1938
1939         heightValue = calcContentBoxHeight(height.calcValue(containerHeight));
1940         topValue = top.calcValue(containerHeight);
1941
1942         const int availableSpace = containerHeight - (topValue + heightValue + bottom.calcValue(containerHeight) + bordersPlusPadding);
1943
1944         // Margins are now the only unknown
1945         if (marginTop.isAuto() && marginBottom.isAuto()) {
1946             // Both margins auto, solve for equality
1947             // NOTE: This may result in negative values.
1948             marginTopValue = availableSpace / 2; // split the diference
1949             marginBottomValue = availableSpace - marginTopValue; // account for odd valued differences
1950         } else if (marginTop.isAuto()) {
1951             // Solve for top margin
1952             marginBottomValue = marginBottom.calcValue(containerHeight);
1953             marginTopValue = availableSpace - marginBottomValue;
1954         } else if (marginBottom.isAuto()) {
1955             // Solve for bottom margin
1956             marginTopValue = marginTop.calcValue(containerHeight);
1957             marginBottomValue = availableSpace - marginTopValue;
1958         } else {
1959             // Over-constrained, (no need solve for bottom)
1960             marginTopValue = marginTop.calcValue(containerHeight);
1961             marginBottomValue = marginBottom.calcValue(containerHeight);
1962         }
1963     } else {
1964         /*--------------------------------------------------------------------*\
1965          * Otherwise, set 'auto' values for 'margin-top' and 'margin-bottom'
1966          * to 0, and pick the one of the following six rules that applies.
1967          *
1968          * 1. 'top' and 'height' are 'auto' and 'bottom' is not 'auto', then 
1969          *    the height is based on the content, and solve for 'top'.
1970          *
1971          *              OMIT RULE 2 AS IT SHOULD NEVER BE HIT
1972          * ------------------------------------------------------------------
1973          * 2. 'top' and 'bottom' are 'auto' and 'height' is not 'auto', then
1974          *    set 'top' to the static position, and solve for 'bottom'.
1975          * ------------------------------------------------------------------
1976          *
1977          * 3. 'height' and 'bottom' are 'auto' and 'top' is not 'auto', then
1978          *    the height is based on the content, and solve for 'bottom'.
1979          * 4. 'top' is 'auto', 'height' and 'bottom' are not 'auto', and
1980          *    solve for 'top'.
1981          * 5. 'height' is 'auto', 'top' and 'bottom' are not 'auto', and
1982          *    solve for 'height'.
1983          * 6. 'bottom' is 'auto', 'top' and 'height' are not 'auto', and
1984          *    solve for 'bottom'.
1985         \*--------------------------------------------------------------------*/
1986         // NOTE: For rules 3 and 6 it is not necessary to solve for 'bottom'
1987         // because the value is not used for any further calculations.
1988
1989         // Calculate margins, 'auto' margins are ignored.
1990         marginTopValue = marginTop.calcMinValue(containerHeight);
1991         marginBottomValue = marginBottom.calcMinValue(containerHeight);
1992
1993         const int availableSpace = containerHeight - (marginTopValue + marginBottomValue + bordersPlusPadding);
1994
1995         // Use rule/case that applies.
1996         if (topIsAuto && heightIsAuto && !bottomIsAuto) {
1997             // RULE 1: (height is content based, solve of top)
1998             heightValue = contentHeight;
1999             topValue = availableSpace - (heightValue + bottom.calcValue(containerHeight));
2000         } else if (!topIsAuto && heightIsAuto && bottomIsAuto) {
2001             // RULE 3: (height is content based, no need solve of bottom)
2002             topValue = top.calcValue(containerHeight);
2003             heightValue = contentHeight;
2004         } else if (topIsAuto && !heightIsAuto && !bottomIsAuto) {
2005             // RULE 4: (solve of top)
2006             heightValue = calcContentBoxHeight(height.calcValue(containerHeight));
2007             topValue = availableSpace - (heightValue + bottom.calcValue(containerHeight));
2008         } else if (!topIsAuto && heightIsAuto && !bottomIsAuto) {
2009             // RULE 5: (solve of height)
2010             topValue = top.calcValue(containerHeight);
2011             heightValue = max(0, availableSpace - (topValue + bottom.calcValue(containerHeight)));
2012         } else if (!topIsAuto && !heightIsAuto && bottomIsAuto) {
2013             // RULE 6: (no need solve of bottom)
2014             heightValue = calcContentBoxHeight(height.calcValue(containerHeight));
2015             topValue = top.calcValue(containerHeight);
2016         }
2017     }
2018
2019     // Use computed values to calculate the vertical position.
2020     yPos = topValue + marginTopValue + containerBlock->borderTop();
2021 }
2022
2023 void RenderBox::calcAbsoluteHorizontalReplaced()
2024 {   
2025     // The following is based off of the W3C Working Draft from April 11, 2006 of
2026     // CSS 2.1: Section 10.3.8 "Absolutly positioned, replaced elements"
2027     // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-replaced-width>
2028     // (block-style-comments in this function correspond to text from the spec and
2029     // the numbers correspond to numbers in spec)
2030
2031     // We don't use containingBlock(), since we may be positioned by an enclosing
2032     // relative positioned inline.
2033     const RenderObject* containerBlock = container();
2034
2035     const int containerWidth = containingBlockWidthForPositioned(containerBlock);
2036     
2037     // To match WinIE, in quirks mode use the parent's 'direction' property 
2038     // instead of the the container block's.
2039     TextDirection containerDirection = (style()->htmlHacks()) ? parent()->style()->direction() : containerBlock->style()->direction();
2040
2041     // Variables to solve.
2042     Length left = style()->left();
2043     Length right = style()->right();
2044     Length marginLeft = style()->marginLeft();
2045     Length marginRight = style()->marginRight();
2046
2047
2048     /*-----------------------------------------------------------------------*\
2049      * 1. The used value of 'width' is determined as for inline replaced
2050      *    elements.
2051     \*-----------------------------------------------------------------------*/
2052     // NOTE: This value of width is FINAL in that the min/max width calculations
2053     // are dealt with in calcReplacedWidth().  This means that the steps to produce
2054     // correct max/min in the non-replaced version, are not necessary.
2055     m_width = calcReplacedWidth() + borderLeft() + borderRight() + paddingLeft() + paddingRight();
2056     const int availableSpace = containerWidth - m_width;
2057
2058     /*-----------------------------------------------------------------------*\
2059      * 2. If both 'left' and 'right' have the value 'auto', then if 'direction'
2060      *    of the containing block is 'ltr', set 'left' to the static position;
2061      *    else if 'direction' is 'rtl', set 'right' to the static position.
2062     \*-----------------------------------------------------------------------*/
2063     // see FIXME 2
2064     if (left.isAuto() && right.isAuto()) {
2065         // see FIXME 1
2066         if (containerDirection == LTR) {
2067             // 'm_staticX' should already have been set through layout of the parent.
2068             int staticPosition = m_staticX - containerBlock->borderLeft();
2069             for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent())
2070                 staticPosition += po->xPos();
2071             left.setValue(Fixed, staticPosition);
2072         } else {
2073             RenderObject* po = parent();
2074             // 'm_staticX' should already have been set through layout of the parent.
2075             int staticPosition = m_staticX + containerWidth + containerBlock->borderRight() - po->width();
2076             for (; po && po != containerBlock; po = po->parent())
2077                 staticPosition -= po->xPos();
2078             right.setValue(Fixed, staticPosition);
2079         }
2080     }
2081
2082     /*-----------------------------------------------------------------------*\
2083      * 3. If 'left' or 'right' are 'auto', replace any 'auto' on 'margin-left'
2084      *    or 'margin-right' with '0'.
2085     \*-----------------------------------------------------------------------*/
2086     if (left.isAuto() || right.isAuto()) {
2087         if (marginLeft.isAuto())
2088             marginLeft.setValue(Fixed, 0);
2089         if (marginRight.isAuto())
2090             marginRight.setValue(Fixed, 0);
2091     }
2092
2093     /*-----------------------------------------------------------------------*\
2094      * 4. If at this point both 'margin-left' and 'margin-right' are still
2095      *    'auto', solve the equation under the extra constraint that the two
2096      *    margins must get equal values, unless this would make them negative,
2097      *    in which case when the direction of the containing block is 'ltr'
2098      *    ('rtl'), set 'margin-left' ('margin-right') to zero and solve for
2099      *    'margin-right' ('margin-left').
2100     \*-----------------------------------------------------------------------*/
2101     int leftValue = 0;
2102     int rightValue = 0;
2103
2104     if (marginLeft.isAuto() && marginRight.isAuto()) {
2105         // 'left' and 'right' cannot be 'auto' due to step 3
2106         ASSERT(!(left.isAuto() && right.isAuto()));
2107
2108         leftValue = left.calcValue(containerWidth);
2109         rightValue = right.calcValue(containerWidth);
2110
2111         int difference = availableSpace - (leftValue + rightValue);
2112         if (difference > 0) {
2113             m_marginLeft = difference / 2; // split the diference
2114             m_marginRight = difference - m_marginLeft; // account for odd valued differences
2115         } else {
2116             // see FIXME 1
2117             if (containerDirection == LTR) {
2118                 m_marginLeft = 0;
2119                 m_marginRight = difference;  // will be negative
2120             } else {
2121                 m_marginLeft = difference;  // will be negative
2122                 m_marginRight = 0;
2123             }
2124         }
2125
2126     /*-----------------------------------------------------------------------*\
2127      * 5. If at this point there is an 'auto' left, solve the equation for
2128      *    that value.
2129     \*-----------------------------------------------------------------------*/
2130     } else if (left.isAuto()) {
2131         m_marginLeft = marginLeft.calcValue(containerWidth);
2132         m_marginRight = marginRight.calcValue(containerWidth);
2133         rightValue = right.calcValue(containerWidth);
2134
2135         // Solve for 'left'
2136         leftValue = availableSpace - (rightValue + m_marginLeft + m_marginRight);
2137     } else if (right.isAuto()) {
2138         m_marginLeft = marginLeft.calcValue(containerWidth);
2139         m_marginRight = marginRight.calcValue(containerWidth);
2140         leftValue = left.calcValue(containerWidth);
2141
2142         // Solve for 'right'
2143         rightValue = availableSpace - (leftValue + m_marginLeft + m_marginRight);
2144     } else if (marginLeft.isAuto()) {
2145         m_marginRight = marginRight.calcValue(containerWidth);
2146         leftValue = left.calcValue(containerWidth);
2147         rightValue = right.calcValue(containerWidth);
2148
2149         // Solve for 'margin-left'
2150         m_marginLeft = availableSpace - (leftValue + rightValue + m_marginRight);
2151     } else if (marginRight.isAuto()) {
2152         m_marginLeft = marginLeft.calcValue(containerWidth);
2153         leftValue = left.calcValue(containerWidth);
2154         rightValue = right.calcValue(containerWidth);
2155
2156         // Solve for 'margin-right'
2157         m_marginRight = availableSpace - (leftValue + rightValue + m_marginLeft);
2158     } else {
2159         // Nothing is 'auto', just calculate the values.
2160         m_marginLeft = marginLeft.calcValue(containerWidth);
2161         m_marginRight = marginRight.calcValue(containerWidth);
2162         rightValue = right.calcValue(containerWidth);
2163         leftValue = left.calcValue(containerWidth);
2164     }
2165
2166     /*-----------------------------------------------------------------------*\
2167      * 6. If at this point the values are over-constrained, ignore the value
2168      *    for either 'left' (in case the 'direction' property of the
2169      *    containing block is 'rtl') or 'right' (in case 'direction' is
2170      *    'ltr') and solve for that value.
2171     \*-----------------------------------------------------------------------*/
2172     // NOTE:  It is not necessary to solve for 'right' when the direction is
2173     // LTR because the value is not used.
2174     int totalWidth = m_width + leftValue + rightValue +  m_marginLeft + m_marginRight;
2175     if (totalWidth > containerWidth && (containerDirection == RTL))
2176         leftValue = containerWidth - (totalWidth - leftValue);
2177
2178     // Use computed values to calculate the horizontal position.
2179
2180     // FIXME: This hack is needed to calculate the xPos for a 'rtl' relatively 
2181     // positioned, inline containing block because right now, it is using the xPos 
2182     // of the first line box when really it should use the last line box.  When 
2183     // this is fixed elsewhere, this block should be removed.
2184     if (containerBlock->isInline() && containerBlock->style()->direction() == RTL) {
2185         const RenderFlow* flow = static_cast<const RenderFlow*>(containerBlock);
2186         InlineFlowBox* firstLine = flow->firstLineBox();
2187         InlineFlowBox* lastLine = flow->lastLineBox();
2188         if (firstLine && lastLine && firstLine != lastLine) {
2189             m_x = leftValue + m_marginLeft + lastLine->borderLeft() + (lastLine->xPos() - firstLine->xPos());
2190             return;
2191         }
2192     }
2193
2194     m_x = leftValue + m_marginLeft + containerBlock->borderLeft();
2195 }
2196
2197 void RenderBox::calcAbsoluteVerticalReplaced()
2198 {
2199     // The following is based off of the W3C Working Draft from April 11, 2006 of
2200     // CSS 2.1: Section 10.6.5 "Absolutly positioned, replaced elements"
2201     // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-replaced-height>
2202     // (block-style-comments in this function correspond to text from the spec and
2203     // the numbers correspond to numbers in spec)
2204
2205     // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline.
2206     const RenderObject* containerBlock = container();
2207
2208     const int containerHeight = containingBlockHeightForPositioned(containerBlock);
2209
2210     // Variables to solve.
2211     Length top = style()->top();
2212     Length bottom = style()->bottom();
2213     Length marginTop = style()->marginTop();
2214     Length marginBottom = style()->marginBottom();
2215
2216
2217     /*-----------------------------------------------------------------------*\
2218      * 1. The used value of 'height' is determined as for inline replaced
2219      *    elements.
2220     \*-----------------------------------------------------------------------*/
2221     // NOTE: This value of height is FINAL in that the min/max height calculations
2222     // are dealt with in calcReplacedHeight().  This means that the steps to produce
2223     // correct max/min in the non-replaced version, are not necessary.
2224     m_height = calcReplacedHeight() + borderTop() + borderBottom() + paddingTop() + paddingBottom();
2225     const int availableSpace = containerHeight - m_height;
2226
2227     /*-----------------------------------------------------------------------*\
2228      * 2. If both 'top' and 'bottom' have the value 'auto', replace 'top'
2229      *    with the element's static position.
2230     \*-----------------------------------------------------------------------*/
2231     // see FIXME 2
2232     if (top.isAuto() && bottom.isAuto()) {
2233         // m_staticY should already have been set through layout of the parent().
2234         int staticTop = m_staticY - containerBlock->borderTop();
2235         for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) {
2236             if (!po->isTableRow())
2237                 staticTop += po->yPos();
2238         }
2239         top.setValue(Fixed, staticTop);
2240     }
2241
2242     /*-----------------------------------------------------------------------*\
2243      * 3. If 'bottom' is 'auto', replace any 'auto' on 'margin-top' or
2244      *    'margin-bottom' with '0'.
2245     \*-----------------------------------------------------------------------*/
2246     // FIXME: The spec. says that this step should only be taken when bottom is
2247     // auto, but if only top is auto, this makes step 4 impossible.
2248     if (top.isAuto() || bottom.isAuto()) {
2249         if (marginTop.isAuto())
2250             marginTop.setValue(Fixed, 0);
2251         if (marginBottom.isAuto())
2252             marginBottom.setValue(Fixed, 0);
2253     }
2254
2255     /*-----------------------------------------------------------------------*\
2256      * 4. If at this point both 'margin-top' and 'margin-bottom' are still
2257      *    'auto', solve the equation under the extra constraint that the two
2258      *    margins must get equal values.
2259     \*-----------------------------------------------------------------------*/
2260     int topValue = 0;
2261     int bottomValue = 0;
2262
2263     if (marginTop.isAuto() && marginBottom.isAuto()) {
2264         // 'top' and 'bottom' cannot be 'auto' due to step 2 and 3 combinded.
2265         ASSERT(!(top.isAuto() || bottom.isAuto()));
2266
2267         topValue = top.calcValue(containerHeight);
2268         bottomValue = bottom.calcValue(containerHeight);
2269
2270         int difference = availableSpace - (topValue + bottomValue);
2271         // NOTE: This may result in negative values.
2272         m_marginTop =  difference / 2; // split the difference
2273         m_marginBottom = difference - m_marginTop; // account for odd valued differences
2274
2275     /*-----------------------------------------------------------------------*\
2276      * 5. If at this point there is only one 'auto' left, solve the equation
2277      *    for that value.
2278     \*-----------------------------------------------------------------------*/
2279     } else if (top.isAuto()) {
2280         m_marginTop = marginTop.calcValue(containerHeight);
2281         m_marginBottom = marginBottom.calcValue(containerHeight);
2282         bottomValue = bottom.calcValue(containerHeight);
2283
2284         // Solve for 'top'
2285         topValue = availableSpace - (bottomValue + m_marginTop + m_marginBottom);
2286     } else if (bottom.isAuto()) {
2287         m_marginTop = marginTop.calcValue(containerHeight);
2288         m_marginBottom = marginBottom.calcValue(containerHeight);
2289         topValue = top.calcValue(containerHeight);
2290
2291         // Solve for 'bottom'
2292         // NOTE: It is not necessary to solve for 'bottom' because we don't ever
2293         // use the value.
2294     } else if (marginTop.isAuto()) {
2295         m_marginBottom = marginBottom.calcValue(containerHeight);
2296         topValue = top.calcValue(containerHeight);
2297         bottomValue = bottom.calcValue(containerHeight);
2298
2299         // Solve for 'margin-top'
2300         m_marginTop = availableSpace - (topValue + bottomValue + m_marginBottom);
2301     } else if (marginBottom.isAuto()) {
2302         m_marginTop = marginTop.calcValue(containerHeight);
2303         topValue = top.calcValue(containerHeight);
2304         bottomValue = bottom.calcValue(containerHeight);
2305
2306         // Solve for 'margin-bottom'
2307         m_marginBottom = availableSpace - (topValue + bottomValue + m_marginTop);
2308     } else {
2309         // Nothing is 'auto', just calculate the values.
2310         m_marginTop = marginTop.calcValue(containerHeight);
2311         m_marginBottom = marginBottom.calcValue(containerHeight);
2312         topValue = top.calcValue(containerHeight);
2313         // NOTE: It is not necessary to solve for 'bottom' because we don't ever
2314         // use the value.
2315      }
2316
2317     /*-----------------------------------------------------------------------*\
2318      * 6. If at this point the values are over-constrained, ignore the value
2319      *    for 'bottom' and solve for that value.
2320     \*-----------------------------------------------------------------------*/
2321     // NOTE: It is not necessary to do this step because we don't end up using
2322     // the value of 'bottom' regardless of whether the values are over-constrained
2323     // or not.
2324
2325     // Use computed values to calculate the vertical position.
2326     m_y = topValue + m_marginTop + containerBlock->borderTop();
2327 }
2328
2329 IntRect RenderBox::caretRect(int offset, EAffinity affinity, int* extraWidthToEndOfLine)
2330 {
2331     // VisiblePositions at offsets inside containers either a) refer to the positions before/after
2332     // those containers (tables and select elements) or b) refer to the position inside an empty block.
2333     // They never refer to children.
2334     // FIXME: Paint the carets inside empty blocks differently than the carets before/after elements.
2335     
2336     // FIXME: What about border and padding?
2337     const int caretWidth = 1;
2338     IntRect rect(xPos(), yPos(), caretWidth, m_height);
2339     if (offset != 0)
2340         rect.move(IntSize(m_width - caretWidth, 0));
2341     if (InlineBox* box = inlineBoxWrapper()) {
2342         RootInlineBox* rootBox = box->root();
2343         int top = rootBox->topOverflow();
2344         rect.setY(top);
2345         rect.setHeight(rootBox->bottomOverflow() - top);
2346     }
2347
2348     // If height of box is smaller than font height, use the latter one,
2349     // otherwise the caret might become invisible.
2350     // 
2351     // Also, if the box is not a replaced element, always use the font height.
2352     // This prevents the "big caret" bug described in:
2353     // <rdar://problem/3777804> Deleting all content in a document can result in giant tall-as-window insertion point
2354     //
2355     // FIXME: ignoring :first-line, missing good reason to take care of
2356     int fontHeight = style()->font().height();
2357     if (fontHeight > rect.height() || !isReplaced() && !isTable())
2358         rect.setHeight(fontHeight);
2359
2360     RenderObject* cb = containingBlock();
2361     int cbx, cby;
2362     if (!cb || !cb->absolutePosition(cbx, cby))
2363         // No point returning a relative position.
2364         return IntRect();
2365
2366     if (extraWidthToEndOfLine)
2367         *extraWidthToEndOfLine = xPos() + m_width - rect.right();
2368
2369     rect.move(cbx, cby);
2370     return rect;
2371 }
2372
2373 int RenderBox::lowestPosition(bool includeOverflowInterior, bool includeSelf) const
2374 {
2375     if (!includeSelf || !m_width)
2376         return 0;
2377     int bottom = m_height;
2378     if (isRelPositioned())
2379         bottom += relativePositionOffsetY();
2380     return bottom;
2381 }
2382
2383 int RenderBox::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const
2384 {
2385     if (!includeSelf || !m_height)
2386         return 0;
2387     int right = m_width;
2388     if (isRelPositioned())
2389         right += relativePositionOffsetX();
2390     return right;
2391 }
2392
2393 int RenderBox::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const
2394 {
2395     if (!includeSelf || !m_height)
2396         return m_width;
2397     int left = 0;
2398     if (isRelPositioned())
2399         left += relativePositionOffsetX();
2400     return left;
2401 }
2402
2403 }