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