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