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