#include "config.h"
#include "RenderBox.h"
#include "CachedImage.h"
#include "Document.h"
#include "FrameView.h"
#include "GraphicsContext.h"
#include "HTMLElement.h"
#include "HTMLNames.h"
#include "Frame.h"
#include "RenderArena.h"
#include "RenderFlexibleBox.h"
#include "RenderLayer.h"
#include "RenderTableCell.h"
#include "RenderTheme.h"
#include "RenderView.h"
#include <algorithm>
#include <math.h>
using std::min;
using std::max;
namespace WebCore {
using namespace HTMLNames;
typedef WTF::HashMap<const RenderBox*, int> OverrideSizeMap;
static OverrideSizeMap* gOverrideSizeMap = 0;
RenderBox::RenderBox(Node* node)
: RenderObject(node)
, m_width(0)
, m_height(0)
, m_x(0)
, m_y(0)
, m_marginLeft(0)
, m_marginRight(0)
, m_marginTop(0)
, m_marginBottom(0)
, m_minPrefWidth(-1)
, m_maxPrefWidth(-1)
, m_layer(0)
, m_inlineBoxWrapper(0)
{
}
void RenderBox::setStyle(RenderStyle* newStyle)
{
bool wasFloating = isFloating();
bool hadOverflowClip = hasOverflowClip();
RenderStyle* oldStyle = style();
if (oldStyle)
oldStyle->ref();
RenderObject::setStyle(newStyle);
if (isRoot() || isRenderView())
setHasBoxDecorations(true);
setInline(newStyle->isDisplayInlineType());
switch (newStyle->position()) {
case AbsolutePosition:
case FixedPosition:
setPositioned(true);
break;
default:
setPositioned(false);
if (newStyle->isFloating())
setFloating(true);
if (newStyle->position() == RelativePosition)
setRelPositioned(true);
}
if (!isRoot() && (!isBody() || !document()->isHTMLDocument()) && (isRenderBlock() || isTableRow() || isTableSection())) {
if (newStyle->overflowX() != OVISIBLE) {
if (!hadOverflowClip)
repaint();
setHasOverflowClip();
}
}
setHasTransform(newStyle->hasTransform());
if (requiresLayer()) {
if (!m_layer) {
if (wasFloating && isFloating())
setChildNeedsLayout(true);
m_layer = new (renderArena()) RenderLayer(this);
setHasLayer(true);
m_layer->insertOnlyThisLayer();
if (parent() && !needsLayout() && containingBlock())
m_layer->updateLayerPositions();
}
} else if (m_layer && !isRoot() && !isRenderView()) {
ASSERT(m_layer->parent());
RenderLayer* layer = m_layer;
m_layer = 0;
setHasLayer(false);
setHasTransform(false); layer->removeOnlyThisLayer();
if (wasFloating && isFloating())
setChildNeedsLayout(true);
}
if (m_layer)
m_layer->styleChanged();
if (isBody())
document()->setTextColor(newStyle->color());
if (style()->outlineWidth() > 0 && style()->outlineSize() > maximalOutlineSize(PaintPhaseOutline))
static_cast<RenderView*>(document()->renderer())->setMaximalOutlineSize(style()->outlineSize());
if (oldStyle)
oldStyle->deref(renderArena());
}
RenderBox::~RenderBox()
{
}
void RenderBox::destroy()
{
if (hasOverrideSize())
gOverrideSizeMap->remove(this);
if (m_layer)
m_layer->clearClipRect();
RenderObject::destroy();
}
int RenderBox::minPrefWidth() const
{
if (prefWidthsDirty())
const_cast<RenderBox*>(this)->calcPrefWidths();
return m_minPrefWidth;
}
int RenderBox::maxPrefWidth() const
{
if (prefWidthsDirty())
const_cast<RenderBox*>(this)->calcPrefWidths();
return m_maxPrefWidth;
}
int RenderBox::overrideSize() const
{
if (!hasOverrideSize())
return -1;
return gOverrideSizeMap->get(this);
}
void RenderBox::setOverrideSize(int s)
{
if (s == -1) {
if (hasOverrideSize()) {
setHasOverrideSize(false);
gOverrideSizeMap->remove(this);
}
} else {
if (!gOverrideSizeMap)
gOverrideSizeMap = new OverrideSizeMap();
setHasOverrideSize(true);
gOverrideSizeMap->set(this, s);
}
}
int RenderBox::overrideWidth() const
{
return hasOverrideSize() ? overrideSize() : m_width;
}
int RenderBox::overrideHeight() const
{
return hasOverrideSize() ? overrideSize() : m_height;
}
void RenderBox::setPos(int xPos, int yPos)
{
if (xPos == m_x && yPos == m_y)
return;
m_x = xPos;
m_y = yPos;
}
int RenderBox::calcBorderBoxWidth(int width) const
{
int bordersPlusPadding = borderLeft() + borderRight() + paddingLeft() + paddingRight();
if (style()->boxSizing() == CONTENT_BOX)
return width + bordersPlusPadding;
return max(width, bordersPlusPadding);
}
int RenderBox::calcBorderBoxHeight(int height) const
{
int bordersPlusPadding = borderTop() + borderBottom() + paddingTop() + paddingBottom();
if (style()->boxSizing() == CONTENT_BOX)
return height + bordersPlusPadding;
return max(height, bordersPlusPadding);
}
int RenderBox::calcContentBoxWidth(int width) const
{
if (style()->boxSizing() == BORDER_BOX)
width -= (borderLeft() + borderRight() + paddingLeft() + paddingRight());
return max(0, width);
}
int RenderBox::calcContentBoxHeight(int height) const
{
if (style()->boxSizing() == BORDER_BOX)
height -= (borderTop() + borderBottom() + paddingTop() + paddingBottom());
return max(0, height);
}
bool RenderBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty, HitTestAction action)
{
tx += m_x;
ty += m_y;
for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
if (!child->hasLayer() && !child->isInlineFlow() && child->nodeAtPoint(request, result, x, y, tx, ty, action)) {
updateHitTestResult(result, IntPoint(x - tx, y - ty));
return true;
}
}
if (style()->visibility() == VISIBLE && action == HitTestForeground && IntRect(tx, ty, m_width, m_height).contains(x, y)) {
updateHitTestResult(result, IntPoint(x - tx, y - ty));
return true;
}
return false;
}
void RenderBox::paint(PaintInfo& paintInfo, int tx, int ty)
{
tx += m_x;
ty += m_y;
PaintInfo childInfo(paintInfo);
childInfo.paintingRoot = paintingRootForChildren(paintInfo);
for (RenderObject* child = firstChild(); child; child = child->nextSibling())
child->paint(childInfo, tx, ty);
}
void RenderBox::paintRootBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
{
const BackgroundLayer* bgLayer = style()->backgroundLayers();
Color bgColor = style()->backgroundColor();
if (document()->isHTMLDocument() && !style()->hasBackground()) {
HTMLElement* body = document()->body();
RenderObject* bodyObject = (body && body->hasLocalName(bodyTag)) ? body->renderer() : 0;
if (bodyObject) {
bgLayer = bodyObject->style()->backgroundLayers();
bgColor = bodyObject->style()->backgroundColor();
}
}
int w = width();
int h = height();
int rw;
int rh;
if (view()->frameView()) {
rw = view()->frameView()->contentsWidth();
rh = view()->frameView()->contentsHeight();
} else {
rw = view()->width();
rh = view()->height();
}
int bx = tx - marginLeft();
int by = ty - marginTop();
int bw = max(w + marginLeft() + marginRight() + borderLeft() + borderRight(), rw);
int bh = max(h + marginTop() + marginBottom() + borderTop() + borderBottom(), rh);
int my = max(by, paintInfo.rect.y());
paintBackgrounds(paintInfo.context, bgColor, bgLayer, my, paintInfo.rect.height(), bx, by, bw, bh);
if (style()->hasBorder() && style()->display() != INLINE)
paintBorder(paintInfo.context, tx, ty, w, h, style());
}
void RenderBox::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
{
if (!shouldPaintWithinRoot(paintInfo))
return;
if (isRoot()) {
paintRootBoxDecorations(paintInfo, tx, ty);
return;
}
int w = width();
int h = height() + borderTopExtra() + borderBottomExtra();
ty -= borderTopExtra();
borderFitAdjust(tx, w);
int my = max(ty, paintInfo.rect.y());
int mh;
if (ty < paintInfo.rect.y())
mh = max(0, h - (paintInfo.rect.y() - ty));
else
mh = min(paintInfo.rect.height(), h);
paintBoxShadow(paintInfo.context, tx, ty, w, h, style());
bool themePainted = style()->hasAppearance() && !theme()->paint(this, paintInfo, IntRect(tx, ty, w, h));
if (!themePainted) {
if (!isBody() || !document()->isHTMLDocument() || document()->documentElement()->renderer()->style()->hasBackground())
paintBackgrounds(paintInfo.context, style()->backgroundColor(), style()->backgroundLayers(), my, mh, tx, ty, w, h);
if (style()->hasAppearance())
theme()->paintDecorations(this, paintInfo, IntRect(tx, ty, w, h));
}
if ((!style()->hasAppearance() || (!themePainted && theme()->paintBorderOnly(this, paintInfo, IntRect(tx, ty, w, h)))) && style()->hasBorder())
paintBorder(paintInfo.context, tx, ty, w, h, style());
}
void RenderBox::paintBackgrounds(GraphicsContext* context, const Color& c, const BackgroundLayer* bgLayer,
int clipY, int clipH, int tx, int ty, int width, int height)
{
if (!bgLayer)
return;
paintBackgrounds(context, c, bgLayer->next(), clipY, clipH, tx, ty, width, height);
paintBackground(context, c, bgLayer, clipY, clipH, tx, ty, width, height);
}
void RenderBox::paintBackground(GraphicsContext* context, const Color& c, const BackgroundLayer* bgLayer,
int clipY, int clipH, int tx, int ty, int width, int height)
{
paintBackgroundExtended(context, c, bgLayer, clipY, clipH, tx, ty, width, height);
}
IntSize RenderBox::calculateBackgroundSize(const BackgroundLayer* bgLayer, int scaledWidth, int scaledHeight) const
{
CachedImage* bg = bgLayer->backgroundImage();
bg->setImageContainerSize(IntSize(m_width, m_height));
if (bgLayer->isBackgroundSizeSet()) {
int w = scaledWidth;
int h = scaledHeight;
Length bgWidth = bgLayer->backgroundSize().width;
Length bgHeight = bgLayer->backgroundSize().height;
if (bgWidth.isPercent())
w = bgWidth.calcValue(scaledWidth);
else if (bgWidth.isFixed())
w = bgWidth.value();
else if (bgWidth.isAuto()) {
if (bgHeight.isPercent()) {
int scaledH = bgHeight.calcValue(scaledHeight);
w = bg->imageSize().width() * scaledH / bg->imageSize().height();
} else if (bgHeight.isFixed())
w = bg->imageSize().width() * bgHeight.value() / bg->imageSize().height();
}
if (bgHeight.isPercent())
h = bgHeight.calcValue(scaledHeight);
else if (bgHeight.isFixed())
h = bgHeight.value();
else if (bgHeight.isAuto()) {
if (bgWidth.isPercent())
h = bg->imageSize().height() * scaledWidth / bg->imageSize().width();
else if (bgWidth.isFixed())
h = bg->imageSize().height() * bgWidth.value() / bg->imageSize().width();
else if (bgWidth.isAuto()) {
w = bg->imageSize().width();
h = bg->imageSize().height();
}
}
return IntSize(max(1, w), max(1, h));
} else
return bg->imageSize();
}
void RenderBox::imageChanged(CachedImage* image)
{
if (!image || !image->canRender() || !parent() || !view())
return;
if (isInlineFlow() || style()->borderImage().image() == image) {
repaint();
return;
}
bool didFullRepaint = false;
IntRect absoluteRect;
RenderBox* backgroundRenderer;
if (isRoot() || (isBody() && document()->isHTMLDocument() && !document()->documentElement()->renderer()->style()->hasBackground())) {
backgroundRenderer = view();
int rw;
int rh;
if (FrameView* frameView = static_cast<RenderView*>(backgroundRenderer)->frameView()) {
rw = frameView->contentsWidth();
rh = frameView->contentsHeight();
} else {
rw = backgroundRenderer->width();
rh = backgroundRenderer->height();
}
absoluteRect = IntRect(-backgroundRenderer->marginLeft(),
-backgroundRenderer->marginTop(),
max(backgroundRenderer->width() + backgroundRenderer->marginLeft() + backgroundRenderer->marginRight() + backgroundRenderer->borderLeft() + backgroundRenderer->borderRight(), rw),
max(backgroundRenderer->height() + backgroundRenderer->marginTop() + backgroundRenderer->marginBottom() + backgroundRenderer->borderTop() + backgroundRenderer->borderBottom(), rh));
} else {
backgroundRenderer = this;
absoluteRect = borderBox();
}
backgroundRenderer->computeAbsoluteRepaintRect(absoluteRect);
for (const BackgroundLayer* bgLayer = style()->backgroundLayers(); bgLayer && !didFullRepaint; bgLayer = bgLayer->next()) {
if (image == bgLayer->backgroundImage()) {
IntRect repaintRect;
IntPoint phase;
IntSize tileSize;
backgroundRenderer->calculateBackgroundImageGeometry(bgLayer, absoluteRect.x(), absoluteRect.y(), absoluteRect.width(), absoluteRect.height(), repaintRect, phase, tileSize);
view()->repaintViewRectangle(repaintRect);
if (repaintRect == absoluteRect)
didFullRepaint = true;
}
}
}
void RenderBox::calculateBackgroundImageGeometry(const BackgroundLayer* bgLayer, int tx, int ty, int w, int h, IntRect& destRect, IntPoint& phase, IntSize& tileSize)
{
int pw;
int ph;
int left = 0;
int right = 0;
int top = 0;
int bottom = 0;
int cx;
int cy;
if (bgLayer->backgroundAttachment()) {
if (bgLayer->backgroundOrigin() != BGBORDER) {
left = borderLeft();
right = borderRight();
top = borderTop();
bottom = borderBottom();
if (bgLayer->backgroundOrigin() == BGCONTENT) {
left += paddingLeft();
right += paddingRight();
top += paddingTop();
bottom += paddingBottom();
}
}
cx = tx;
cy = ty;
pw = w - left - right;
ph = h - top - bottom;
} else {
IntRect vr = viewRect();
cx = vr.x();
cy = vr.y();
pw = vr.width();
ph = vr.height();
}
int sx = 0;
int sy = 0;
int cw;
int ch;
IntSize scaledImageSize = calculateBackgroundSize(bgLayer, pw, ph);
int scaledImageWidth = scaledImageSize.width();
int scaledImageHeight = scaledImageSize.height();
EBackgroundRepeat backgroundRepeat = bgLayer->backgroundRepeat();
int xPosition = bgLayer->backgroundXPosition().calcMinValue(pw - scaledImageWidth);
if (backgroundRepeat == REPEAT || backgroundRepeat == REPEAT_X) {
cw = pw + left + right;
sx = scaledImageWidth ? scaledImageWidth - (xPosition + left) % scaledImageWidth : 0;
} else {
cx += max(xPosition + left, 0);
sx = -min(xPosition + left, 0);
cw = scaledImageWidth + min(xPosition + left, 0);
}
int yPosition = bgLayer->backgroundYPosition().calcMinValue(ph - scaledImageHeight);
if (backgroundRepeat == REPEAT || backgroundRepeat == REPEAT_Y) {
ch = ph + top + bottom;
sy = scaledImageHeight ? scaledImageHeight - (yPosition + top) % scaledImageHeight : 0;
} else {
cy += max(yPosition + top, 0);
sy = -min(yPosition + top, 0);
ch = scaledImageHeight + min(yPosition + top, 0);
}
if (!bgLayer->backgroundAttachment()) {
sx += max(tx - cx, 0);
sy += max(ty - cy, 0);
}
destRect = IntRect(cx, cy, cw, ch);
destRect.intersect(IntRect(tx, ty, w, h));
phase = IntPoint(sx, sy);
tileSize = IntSize(scaledImageWidth, scaledImageHeight);
}
void RenderBox::paintBackgroundExtended(GraphicsContext* context, const Color& c, const BackgroundLayer* bgLayer, int clipY, int clipH,
int tx, int ty, int w, int h, bool includeLeftEdge, bool includeRightEdge)
{
int bLeft = includeLeftEdge ? borderLeft() : 0;
int bRight = includeRightEdge ? borderRight() : 0;
int pLeft = includeLeftEdge ? paddingLeft() : 0;
int pRight = includeRightEdge ? paddingRight() : 0;
bool clippedToBorderRadius = false;
if (style()->hasBorderRadius() && (includeLeftEdge || includeRightEdge)) {
context->save();
context->addRoundedRectClip(IntRect(tx, ty, w, h),
includeLeftEdge ? style()->borderTopLeftRadius() : IntSize(),
includeRightEdge ? style()->borderTopRightRadius() : IntSize(),
includeLeftEdge ? style()->borderBottomLeftRadius() : IntSize(),
includeRightEdge ? style()->borderBottomRightRadius() : IntSize());
clippedToBorderRadius = true;
}
if (bgLayer->backgroundClip() != BGBORDER) {
bool includePadding = bgLayer->backgroundClip() == BGCONTENT;
int x = tx + bLeft + (includePadding ? pLeft : 0);
int y = ty + borderTop() + (includePadding ? paddingTop() : 0);
int width = w - bLeft - bRight - (includePadding ? pLeft + pRight : 0);
int height = h - borderTop() - borderBottom() - (includePadding ? paddingTop() + paddingBottom() : 0);
context->save();
context->clip(IntRect(x, y, width, height));
}
CachedImage* bg = bgLayer->backgroundImage();
bool shouldPaintBackgroundImage = bg && bg->canRender();
Color bgColor = c;
if (style()->forceBackgroundsToWhite()) {
bool shouldPaintBackgroundColor = !bgLayer->next() && bgColor.isValid() && bgColor.alpha() > 0;
if (shouldPaintBackgroundImage || shouldPaintBackgroundColor) {
bgColor = Color::white;
shouldPaintBackgroundImage = false;
}
}
bool isTransparent = false;
if (!bgLayer->next() && isRoot() && !(bgColor.isValid() && bgColor.alpha() > 0) && view()->frameView()) {
Node* elt = document()->ownerElement();
if (elt) {
if (!elt->hasTagName(frameTag)) {
HTMLElement* body = document()->body();
isTransparent = !body || !body->hasLocalName(framesetTag); }
} else
isTransparent = view()->frameView()->isTransparent();
if (isTransparent)
view()->frameView()->setUseSlowRepaints(); }
if (!bgLayer->next()) {
IntRect rect(tx, clipY, w, clipH);
if (isRoot() && (!bgColor.isValid() || bgColor.alpha() < 0xFF) && !isTransparent) {
Color baseColor = view()->frameView()->baseBackgroundColor();
if (baseColor.alpha() > 0) {
context->save();
context->setCompositeOperation(CompositeCopy);
context->fillRect(rect, baseColor);
context->restore();
} else
context->clearRect(rect);
}
if (bgColor.isValid() && bgColor.alpha() > 0)
context->fillRect(rect, bgColor);
}
if (shouldPaintBackgroundImage) {
IntRect destRect;
IntPoint phase;
IntSize tileSize;
calculateBackgroundImageGeometry(bgLayer, tx, ty, w, h, destRect, phase, tileSize);
if (!destRect.isEmpty())
context->drawTiledImage(bg->image(), destRect, phase, tileSize, bgLayer->backgroundComposite());
}
if (bgLayer->backgroundClip() != BGBORDER)
context->restore();
if (clippedToBorderRadius)
context->restore();
}
#if PLATFORM(MAC)
void RenderBox::paintCustomHighlight(int tx, int ty, const AtomicString& type, bool behindText)
{
InlineBox* boxWrap = inlineBoxWrapper();
RootInlineBox* r = boxWrap ? boxWrap->root() : 0;
if (r) {
FloatRect rootRect(tx + r->xPos(), ty + r->selectionTop(), r->width(), r->selectionHeight());
FloatRect imageRect(tx + m_x, rootRect.y(), width(), rootRect.height());
document()->frame()->paintCustomHighlight(type, imageRect, rootRect, behindText, false, node());
} else {
FloatRect imageRect(tx + m_x, ty + m_y, width(), height());
document()->frame()->paintCustomHighlight(type, imageRect, imageRect, behindText, false, node());
}
}
#endif
IntRect RenderBox::getOverflowClipRect(int tx, int ty)
{
int bLeft = borderLeft();
int bTop = borderTop();
int clipX = tx + bLeft;
int clipY = ty + bTop;
int clipWidth = m_width - bLeft - borderRight();
int clipHeight = m_height - bTop - borderBottom() + borderTopExtra() + borderBottomExtra();
if (m_layer) {
clipWidth -= m_layer->verticalScrollbarWidth();
clipHeight -= m_layer->horizontalScrollbarHeight();
}
return IntRect(clipX, clipY, clipWidth, clipHeight);
}
IntRect RenderBox::getClipRect(int tx, int ty)
{
int clipX = tx;
int clipY = ty;
int clipWidth = m_width;
int clipHeight = m_height;
if (!style()->clipLeft().isAuto()) {
int c = style()->clipLeft().calcValue(m_width);
clipX += c;
clipWidth -= c;
}
if (!style()->clipRight().isAuto())
clipWidth -= m_width - style()->clipRight().calcValue(m_width);
if (!style()->clipTop().isAuto()) {
int c = style()->clipTop().calcValue(m_height);
clipY += c;
clipHeight -= c;
}
if (!style()->clipBottom().isAuto())
clipHeight -= m_height - style()->clipBottom().calcValue(m_height);
return IntRect(clipX, clipY, clipWidth, clipHeight);
}
int RenderBox::containingBlockWidth() const
{
RenderBlock* cb = containingBlock();
if (!cb)
return 0;
if (shrinkToAvoidFloats())
return cb->lineWidth(m_y);
return cb->availableWidth();
}
IntSize RenderBox::offsetForPositionedInContainer(RenderObject* container) const
{
if (!container->isRelPositioned() || !container->isInlineFlow())
return IntSize();
IntSize offset;
RenderFlow* flow = static_cast<RenderFlow*>(container);
int sx;
int sy;
if (flow->firstLineBox()) {
sx = flow->firstLineBox()->xPos();
sy = flow->firstLineBox()->yPos();
} else {
sx = flow->staticX();
sy = flow->staticY();
}
if (!hasStaticX())
offset.setWidth(sx);
else if (!style()->isOriginalDisplayInlineType())
offset.setWidth(sx - (containingBlock()->borderLeft() + containingBlock()->paddingLeft()));
if (!hasStaticY())
offset.setHeight(sy);
return offset;
}
bool RenderBox::absolutePosition(int& xPos, int& yPos, bool fixed) const
{
if (RenderView* v = view()) {
if (LayoutState* layoutState = v->layoutState()) {
xPos = layoutState->m_offset.width() + m_x;
yPos = layoutState->m_offset.height() + m_y;
return true;
}
}
if (style()->position() == FixedPosition)
fixed = true;
RenderObject* o = container();
if (o && o->absolutePosition(xPos, yPos, fixed)) {
yPos += o->borderTopExtra();
if (style()->position() == AbsolutePosition) {
IntSize offset = offsetForPositionedInContainer(o);
xPos += offset.width();
yPos += offset.height();
}
if (o->hasOverflowClip())
o->layer()->subtractScrollOffset(xPos, yPos);
if (!isInline() || isReplaced()) {
RenderBlock* cb;
if (o->isBlockFlow() && style()->position() != AbsolutePosition && style()->position() != FixedPosition
&& (cb = static_cast<RenderBlock*>(o))->hasColumns()) {
IntRect rect(m_x, m_y, 1, 1);
cb->adjustRectForColumns(rect);
xPos += rect.x();
yPos += rect.y();
} else {
xPos += m_x;
yPos += m_y;
}
}
if (isRelPositioned()) {
xPos += relativePositionOffsetX();
yPos += relativePositionOffsetY();
}
return true;
} else {
xPos = 0;
yPos = 0;
return false;
}
}
void RenderBox::dirtyLineBoxes(bool fullLayout, bool )
{
if (m_inlineBoxWrapper) {
if (fullLayout) {
m_inlineBoxWrapper->destroy(renderArena());
m_inlineBoxWrapper = 0;
} else
m_inlineBoxWrapper->dirtyLineBoxes();
}
}
void RenderBox::position(InlineBox* box)
{
if (isPositioned()) {
bool wasInline = style()->isOriginalDisplayInlineType();
if (wasInline && hasStaticX()) {
setStaticX(box->xPos());
setChildNeedsLayout(true, false); } else if (!wasInline && hasStaticY()) {
setStaticY(box->yPos());
setChildNeedsLayout(true, false); }
box->remove();
box->destroy(renderArena());
} else if (isReplaced()) {
m_x = box->xPos();
m_y = box->yPos();
m_inlineBoxWrapper = box;
}
}
void RenderBox::deleteLineBoxWrapper()
{
if (m_inlineBoxWrapper) {
if (!documentBeingDestroyed())
m_inlineBoxWrapper->remove();
m_inlineBoxWrapper->destroy(renderArena());
m_inlineBoxWrapper = 0;
}
}
IntRect RenderBox::absoluteClippedOverflowRect()
{
if (style()->visibility() != VISIBLE && !enclosingLayer()->hasVisibleContent())
return IntRect();
IntRect r = overflowRect(false);
if (RenderView* v = view())
r.move(v->layoutDelta());
if (style()) {
if (style()->hasAppearance())
theme()->adjustRepaintRect(this, r);
if (!isInline() && continuation())
r.inflate(continuation()->style()->outlineSize());
else
r.inflate(style()->outlineSize());
}
computeAbsoluteRepaintRect(r);
return r;
}
void RenderBox::computeAbsoluteRepaintRect(IntRect& rect, bool fixed)
{
if (RenderView* v = view()) {
if (LayoutState* layoutState = v->layoutState()) {
rect.move(m_x, m_y);
rect.move(layoutState->m_offset);
if (layoutState->m_clipped)
rect.intersect(layoutState->m_clipRect);
return;
}
}
int x = rect.x() + m_x;
int y = rect.y() + m_y;
if (style()->position() == RelativePosition && m_layer)
m_layer->relativePositionOffset(x, y);
if (style()->position() == FixedPosition)
fixed = true;
RenderObject* o = container();
if (o) {
if (o->isBlockFlow() && style()->position() != AbsolutePosition && style()->position() != FixedPosition) {
RenderBlock* cb = static_cast<RenderBlock*>(o);
if (cb->hasColumns()) {
IntRect repaintRect(x, y, rect.width(), rect.height());
cb->adjustRectForColumns(repaintRect);
x = repaintRect.x();
y = repaintRect.y();
rect = repaintRect;
}
}
if (style()->position() == AbsolutePosition) {
IntSize offset = offsetForPositionedInContainer(o);
x += offset.width();
y += offset.height();
}
if (m_layer && m_layer->transform()) {
fixed = false;
rect = m_layer->transform()->mapRect(rect);
x = rect.x() + m_x;
y = rect.y() + m_y;
}
if (o->hasOverflowClip()) {
IntRect boxRect(0, 0, o->layer()->width(), o->layer()->height());
o->layer()->subtractScrollOffset(x, y); IntRect repaintRect(x, y, rect.width(), rect.height());
rect = intersection(repaintRect, boxRect);
if (rect.isEmpty())
return;
} else {
rect.setX(x);
rect.setY(y);
}
o->computeAbsoluteRepaintRect(rect, fixed);
}
}
void RenderBox::repaintDuringLayoutIfMoved(const IntRect& rect)
{
int newX = m_x;
int newY = m_y;
int newWidth = m_width;
int newHeight = m_height;
if (rect.x() != newX || rect.y() != newY) {
m_x = rect.x();
m_y = rect.y();
m_width = rect.width();
m_height = rect.height();
repaint();
repaintOverhangingFloats(true);
m_x = newX;
m_y = newY;
m_width = newWidth;
m_height = newHeight;
repaint();
repaintOverhangingFloats(true);
}
}
int RenderBox::relativePositionOffsetX() const
{
if (!style()->left().isAuto()) {
if (!style()->right().isAuto() && containingBlock()->style()->direction() == RTL)
return -style()->right().calcValue(containingBlockWidth());
return style()->left().calcValue(containingBlockWidth());
}
if (!style()->right().isAuto())
return -style()->right().calcValue(containingBlockWidth());
return 0;
}
int RenderBox::relativePositionOffsetY() const
{
if (!style()->top().isAuto()) {
if (!style()->top().isPercent() || containingBlock()->style()->height().isFixed())
return style()->top().calcValue(containingBlockHeight());
} else if (!style()->bottom().isAuto()) {
if (!style()->bottom().isPercent() || containingBlock()->style()->height().isFixed())
return -style()->bottom().calcValue(containingBlockHeight());
}
return 0;
}
void RenderBox::calcWidth()
{
if (isPositioned()) {
calcAbsoluteHorizontal();
return;
}
if (node() && view()->frameView() && view()->frameView()->layoutRoot(true) == this)
return;
if (hasOverrideSize() && parent()->style()->boxOrient() == HORIZONTAL
&& parent()->isFlexibleBox() && parent()->isFlexingChildren()) {
m_width = overrideSize();
return;
}
bool inVerticalBox = parent()->isFlexibleBox() && (parent()->style()->boxOrient() == VERTICAL);
bool stretching = (parent()->style()->boxAlign() == BSTRETCH);
bool treatAsReplaced = shouldCalculateSizeAsReplaced() && (!inVerticalBox || !stretching);
Length width = (treatAsReplaced) ? Length(calcReplacedWidth(), Fixed) : style()->width();
RenderBlock* cb = containingBlock();
int containerWidth = max(0, containingBlockWidth());
Length marginLeft = style()->marginLeft();
Length marginRight = style()->marginRight();
if (isInline() && !isInlineBlockOrInlineTable()) {
m_marginLeft = marginLeft.calcMinValue(containerWidth);
m_marginRight = marginRight.calcMinValue(containerWidth);
if (treatAsReplaced)
m_width = max(width.value() + borderLeft() + borderRight() + paddingLeft() + paddingRight(), minPrefWidth());
return;
}
if (treatAsReplaced)
m_width = width.value() + borderLeft() + borderRight() + paddingLeft() + paddingRight();
else {
m_width = calcWidthUsing(Width, containerWidth);
if (!style()->maxWidth().isUndefined()) {
int maxW = calcWidthUsing(MaxWidth, containerWidth);
if (m_width > maxW) {
m_width = maxW;
width = style()->maxWidth();
}
}
int minW = calcWidthUsing(MinWidth, containerWidth);
if (m_width < minW) {
m_width = minW;
width = style()->minWidth();
}
}
if (stretchesToMinIntrinsicWidth()) {
m_width = max(m_width, minPrefWidth());
width = Length(m_width, Fixed);
}
if (width.isAuto()) {
m_marginLeft = marginLeft.calcMinValue(containerWidth);
m_marginRight = marginRight.calcMinValue(containerWidth);
} else {
m_marginLeft = 0;
m_marginRight = 0;
calcHorizontalMargins(marginLeft, marginRight, containerWidth);
}
if (containerWidth && containerWidth != (m_width + m_marginLeft + m_marginRight)
&& !isFloating() && !isInline() && !cb->isFlexibleBox()) {
if (cb->style()->direction() == LTR)
m_marginRight = containerWidth - m_width - m_marginLeft;
else
m_marginLeft = containerWidth - m_width - m_marginRight;
}
}
int RenderBox::calcWidthUsing(WidthType widthType, int cw)
{
int width = m_width;
Length w;
if (widthType == Width)
w = style()->width();
else if (widthType == MinWidth)
w = style()->minWidth();
else
w = style()->maxWidth();
if (w.isIntrinsicOrAuto()) {
int marginLeft = style()->marginLeft().calcMinValue(cw);
int marginRight = style()->marginRight().calcMinValue(cw);
if (cw)
width = cw - marginLeft - marginRight;
if (sizesToIntrinsicWidth(widthType)) {
width = max(width, minPrefWidth());
width = min(width, maxPrefWidth());
}
} else
width = calcBorderBoxWidth(w.calcValue(cw));
return width;
}
bool RenderBox::sizesToIntrinsicWidth(WidthType widthType) const
{
if (isFloating() || (isCompact() && isInline())
|| (isInlineBlockOrInlineTable() && !isHTMLMarquee()))
return true;
Length width = (widthType == MaxWidth) ? style()->maxWidth() : style()->width();
if (width.type() == Intrinsic)
return true;
if (parent()->style()->overflowX() == OMARQUEE) {
EMarqueeDirection dir = parent()->style()->marqueeDirection();
if (dir == MAUTO || dir == MFORWARD || dir == MBACKWARD || dir == MLEFT || dir == MRIGHT)
return true;
}
if (parent()->isFlexibleBox()
&& (parent()->style()->boxOrient() == HORIZONTAL || parent()->style()->boxAlign() != BSTRETCH))
return true;
return false;
}
void RenderBox::calcHorizontalMargins(const Length& marginLeft, const Length& marginRight, int containerWidth)
{
if (isFloating() || isInline()) {
m_marginLeft = marginLeft.calcMinValue(containerWidth);
m_marginRight = marginRight.calcMinValue(containerWidth);
return;
}
if ((marginLeft.isAuto() && marginRight.isAuto() && m_width < containerWidth)
|| (!marginLeft.isAuto() && !marginRight.isAuto() && containingBlock()->style()->textAlign() == WEBKIT_CENTER)) {
m_marginLeft = max(0, (containerWidth - m_width) / 2);
m_marginRight = containerWidth - m_width - m_marginLeft;
} else if ((marginRight.isAuto() && m_width < containerWidth)
|| (!marginLeft.isAuto() && containingBlock()->style()->direction() == RTL && containingBlock()->style()->textAlign() == WEBKIT_LEFT)) {
m_marginLeft = marginLeft.calcValue(containerWidth);
m_marginRight = containerWidth - m_width - m_marginLeft;
} else if ((marginLeft.isAuto() && m_width < containerWidth)
|| (!marginRight.isAuto() && containingBlock()->style()->direction() == LTR && containingBlock()->style()->textAlign() == WEBKIT_RIGHT)) {
m_marginRight = marginRight.calcValue(containerWidth);
m_marginLeft = containerWidth - m_width - m_marginRight;
} else {
m_marginLeft = marginLeft.calcMinValue(containerWidth);
m_marginRight = marginRight.calcMinValue(containerWidth);
}
}
void RenderBox::calcHeight()
{
if (isTableCell() || (isInline() && !isReplaced()))
return;
if (isPositioned())
calcAbsoluteVertical();
else {
calcVerticalMargins();
if (isTable())
return;
Length h;
bool inHorizontalBox = parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL;
bool stretching = parent()->style()->boxAlign() == BSTRETCH;
bool treatAsReplaced = shouldCalculateSizeAsReplaced() && (!inHorizontalBox || !stretching);
bool checkMinMaxHeight = false;
if (hasOverrideSize() && parent()->isFlexibleBox() && parent()->style()->boxOrient() == VERTICAL
&& parent()->isFlexingChildren())
h = Length(overrideSize() - borderTop() - borderBottom() - paddingTop() - paddingBottom(), Fixed);
else if (treatAsReplaced)
h = Length(calcReplacedHeight(), Fixed);
else {
h = style()->height();
checkMinMaxHeight = true;
}
if (h.isAuto() && parent()->isFlexibleBox() && parent()->style()->boxOrient() == HORIZONTAL
&& parent()->isStretchingChildren()) {
h = Length(parent()->contentHeight() - marginTop() - marginBottom() -
borderTop() - paddingTop() - borderBottom() - paddingBottom(), Fixed);
checkMinMaxHeight = false;
}
int height;
if (checkMinMaxHeight) {
height = calcHeightUsing(style()->height());
if (height == -1)
height = m_height;
int minH = calcHeightUsing(style()->minHeight()); int maxH = style()->maxHeight().isUndefined() ? height : calcHeightUsing(style()->maxHeight());
if (maxH == -1)
maxH = height;
height = min(maxH, height);
height = max(minH, height);
} else
height = h.value() + borderTop() + borderBottom() + paddingTop() + paddingBottom();
m_height = height;
}
if (stretchesToViewHeight()) {
int margins = collapsedMarginTop() + collapsedMarginBottom();
int visHeight = view()->frameView()->visibleHeight();
if (isRoot())
m_height = max(m_height, visHeight - margins);
else {
int marginsBordersPadding = margins + parent()->marginTop() + parent()->marginBottom()
+ parent()->borderTop() + parent()->borderBottom()
+ parent()->paddingTop() + parent()->paddingBottom();
m_height = max(m_height, visHeight - marginsBordersPadding);
}
}
}
int RenderBox::calcHeightUsing(const Length& h)
{
int height = -1;
if (!h.isAuto()) {
if (h.isFixed())
height = h.value();
else if (h.isPercent())
height = calcPercentageHeight(h);
if (height != -1) {
height = calcBorderBoxHeight(height);
return height;
}
}
return height;
}
int RenderBox::calcPercentageHeight(const Length& height)
{
int result = -1;
bool includeBorderPadding = isTable();
RenderBlock* cb = containingBlock();
if (style()->htmlHacks()) {
while (!cb->isRenderView() && !cb->isBody() && !cb->isTableCell() && !cb->isPositioned() && cb->style()->height().isAuto())
cb = cb->containingBlock();
}
bool isPositionedWithSpecifiedHeight = cb->isPositioned() && (!cb->style()->height().isAuto() || (!cb->style()->top().isAuto() && !cb->style()->bottom().isAuto()));
if (cb->isTableCell()) {
result = cb->overrideSize();
if (result == -1) {
RenderTableCell* cell = static_cast<RenderTableCell*>(cb);
if (scrollsOverflowY() && (!cell->style()->height().isAuto() || !cell->table()->style()->height().isAuto()))
return 0;
return -1;
}
includeBorderPadding = true;
}
else if (cb->style()->height().isFixed())
result = cb->calcContentBoxHeight(cb->style()->height().value());
else if (cb->style()->height().isPercent() && !isPositionedWithSpecifiedHeight) {
result = cb->calcPercentageHeight(cb->style()->height());
if (result != -1)
result = cb->calcContentBoxHeight(result);
} else if (cb->isRenderView() || (cb->isBody() && style()->htmlHacks()) || isPositionedWithSpecifiedHeight) {
int oldHeight = cb->height();
cb->calcHeight();
result = cb->contentHeight();
cb->setHeight(oldHeight);
} else if (cb->isRoot() && isPositioned())
result = cb->calcContentBoxHeight(cb->availableHeight());
if (result != -1) {
result = height.calcValue(result);
if (includeBorderPadding) {
result -= (borderTop() + paddingTop() + borderBottom() + paddingBottom());
result = max(0, result);
}
}
return result;
}
int RenderBox::calcReplacedWidth() const
{
int width = calcReplacedWidthUsing(style()->width());
int minW = calcReplacedWidthUsing(style()->minWidth());
int maxW = style()->maxWidth().isUndefined() ? width : calcReplacedWidthUsing(style()->maxWidth());
return max(minW, min(width, maxW));
}
int RenderBox::calcReplacedWidthUsing(Length width) const
{
switch (width.type()) {
case Fixed:
return calcContentBoxWidth(width.value());
case Percent: {
const int cw = containingBlockWidth();
if (cw > 0)
return calcContentBoxWidth(width.calcMinValue(cw));
}
default:
return intrinsicSize().width();
}
}
int RenderBox::calcReplacedHeight() const
{
int height = calcReplacedHeightUsing(style()->height());
int minH = calcReplacedHeightUsing(style()->minHeight());
int maxH = style()->maxHeight().isUndefined() ? height : calcReplacedHeightUsing(style()->maxHeight());
return max(minH, min(height, maxH));
}
int RenderBox::calcReplacedHeightUsing(Length height) const
{
switch (height.type()) {
case Fixed:
return calcContentBoxHeight(height.value());
case Percent:
{
RenderObject* cb = isPositioned() ? container() : containingBlock();
if (cb->isPositioned() && cb->style()->height().isAuto() && !(cb->style()->top().isAuto() || cb->style()->bottom().isAuto())) {
ASSERT(cb->isRenderBlock());
RenderBlock* block = static_cast<RenderBlock*>(cb);
int oldHeight = block->height();
block->calcHeight();
int newHeight = block->calcContentBoxHeight(block->contentHeight());
block->setHeight(oldHeight);
return calcContentBoxHeight(height.calcValue(newHeight));
}
int availableHeight = isPositioned() ? containingBlockHeightForPositioned(cb) : cb->availableHeight();
if (cb->isTableCell() && (cb->style()->height().isAuto() || cb->style()->height().isPercent())) {
availableHeight = max(availableHeight, intrinsicSize().height());
return height.calcValue(availableHeight - (borderTop() + borderBottom()
+ paddingTop() + paddingBottom()));
}
return calcContentBoxHeight(height.calcValue(availableHeight));
}
default:
return intrinsicSize().height();
}
}
int RenderBox::availableHeight() const
{
return availableHeightUsing(style()->height());
}
int RenderBox::availableHeightUsing(const Length& h) const
{
if (h.isFixed())
return calcContentBoxHeight(h.value());
if (isRenderView())
return static_cast<const RenderView*>(this)->frameView()->visibleHeight();
if (isTableCell() && (h.isAuto() || h.isPercent()))
return overrideSize() - (borderLeft() + borderRight() + paddingLeft() + paddingRight());
if (h.isPercent())
return calcContentBoxHeight(h.calcValue(containingBlock()->availableHeight()));
return containingBlock()->availableHeight();
}
void RenderBox::calcVerticalMargins()
{
if (isTableCell()) {
m_marginTop = 0;
m_marginBottom = 0;
return;
}
int cw = containingBlock()->contentWidth();
m_marginTop = style()->marginTop().calcMinValue(cw);
m_marginBottom = style()->marginBottom().calcMinValue(cw);
}
int RenderBox::staticX() const
{
return m_layer ? m_layer->staticX() : 0;
}
int RenderBox::staticY() const
{
return m_layer ? m_layer->staticY() : 0;
}
void RenderBox::setStaticX(int staticX)
{
ASSERT(isPositioned() || isRelPositioned());
m_layer->setStaticX(staticX);
}
void RenderBox::setStaticY(int staticY)
{
ASSERT(isPositioned() || isRelPositioned());
if (staticY == m_layer->staticY())
return;
m_layer->setStaticY(staticY);
setChildNeedsLayout(true, false);
}
int RenderBox::containingBlockWidthForPositioned(const RenderObject* containingBlock) const
{
if (containingBlock->isInlineFlow()) {
ASSERT(containingBlock->isRelPositioned());
const RenderFlow* flow = static_cast<const RenderFlow*>(containingBlock);
InlineFlowBox* first = flow->firstLineBox();
InlineFlowBox* last = flow->lastLineBox();
if (!first || !last)
return 0;
int fromLeft;
int fromRight;
if (containingBlock->style()->direction() == LTR) {
fromLeft = first->xPos() + first->borderLeft();
fromRight = last->xPos() + last->width() - last->borderRight();
} else {
fromRight = first->xPos() + first->width() - first->borderRight();
fromLeft = last->xPos() + last->borderLeft();
}
return max(0, (fromRight - fromLeft));
}
return containingBlock->width() - containingBlock->borderLeft() - containingBlock->borderRight() - containingBlock->verticalScrollbarWidth();
}
int RenderBox::containingBlockHeightForPositioned(const RenderObject* containingBlock) const
{
return containingBlock->height() - containingBlock->borderTop() - containingBlock->borderBottom();
}
void RenderBox::calcAbsoluteHorizontal()
{
if (isReplaced()) {
calcAbsoluteHorizontalReplaced();
return;
}
const RenderObject* containerBlock = container();
const int containerWidth = containingBlockWidthForPositioned(containerBlock);
TextDirection containerDirection = (style()->htmlHacks()) ? parent()->style()->direction() : containerBlock->style()->direction();
const int bordersPlusPadding = borderLeft() + borderRight() + paddingLeft() + paddingRight();
const Length marginLeft = style()->marginLeft();
const Length marginRight = style()->marginRight();
Length left = style()->left();
Length right = style()->right();
if (left.isAuto() && right.isAuto()) {
if (containerDirection == LTR) {
int staticPosition = staticX() - containerBlock->borderLeft();
for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent())
staticPosition += po->xPos();
left.setValue(Fixed, staticPosition);
} else {
RenderObject* po = parent();
int staticPosition = staticX() + containerWidth + containerBlock->borderRight() - po->width();
for (; po && po != containerBlock; po = po->parent())
staticPosition -= po->xPos();
right.setValue(Fixed, staticPosition);
}
}
calcAbsoluteHorizontalValues(style()->width(), containerBlock, containerDirection,
containerWidth, bordersPlusPadding,
left, right, marginLeft, marginRight,
m_width, m_marginLeft, m_marginRight, m_x);
if (!style()->maxWidth().isUndefined()) {
int maxWidth;
int maxMarginLeft;
int maxMarginRight;
int maxXPos;
calcAbsoluteHorizontalValues(style()->maxWidth(), containerBlock, containerDirection,
containerWidth, bordersPlusPadding,
left, right, marginLeft, marginRight,
maxWidth, maxMarginLeft, maxMarginRight, maxXPos);
if (m_width > maxWidth) {
m_width = maxWidth;
m_marginLeft = maxMarginLeft;
m_marginRight = maxMarginRight;
m_x = maxXPos;
}
}
if (!style()->minWidth().isZero()) {
int minWidth;
int minMarginLeft;
int minMarginRight;
int minXPos;
calcAbsoluteHorizontalValues(style()->minWidth(), containerBlock, containerDirection,
containerWidth, bordersPlusPadding,
left, right, marginLeft, marginRight,
minWidth, minMarginLeft, minMarginRight, minXPos);
if (m_width < minWidth) {
m_width = minWidth;
m_marginLeft = minMarginLeft;
m_marginRight = minMarginRight;
m_x = minXPos;
}
}
if (stretchesToMinIntrinsicWidth() && m_width < minPrefWidth() - bordersPlusPadding)
calcAbsoluteHorizontalValues(Length(minPrefWidth() - bordersPlusPadding, Fixed), containerBlock, containerDirection,
containerWidth, bordersPlusPadding,
left, right, marginLeft, marginRight,
m_width, m_marginLeft, m_marginRight, m_x);
m_width += bordersPlusPadding;
}
void RenderBox::calcAbsoluteHorizontalValues(Length width, const RenderObject* containerBlock, TextDirection containerDirection,
const int containerWidth, const int bordersPlusPadding,
const Length left, const Length right, const Length marginLeft, const Length marginRight,
int& widthValue, int& marginLeftValue, int& marginRightValue, int& xPos)
{
ASSERT(!(left.isAuto() && right.isAuto()));
int leftValue = 0;
bool widthIsAuto = width.isIntrinsicOrAuto();
bool leftIsAuto = left.isAuto();
bool rightIsAuto = right.isAuto();
if (!leftIsAuto && !widthIsAuto && !rightIsAuto) {
leftValue = left.calcValue(containerWidth);
widthValue = calcContentBoxWidth(width.calcValue(containerWidth));
const int availableSpace = containerWidth - (leftValue + widthValue + right.calcValue(containerWidth) + bordersPlusPadding);
if (marginLeft.isAuto() && marginRight.isAuto()) {
if (availableSpace >= 0) {
marginLeftValue = availableSpace / 2; marginRightValue = availableSpace - marginLeftValue; } else {
if (containerDirection == LTR) {
marginLeftValue = 0;
marginRightValue = availableSpace; } else {
marginLeftValue = availableSpace; marginRightValue = 0;
}
}
} else if (marginLeft.isAuto()) {
marginRightValue = marginRight.calcValue(containerWidth);
marginLeftValue = availableSpace - marginRightValue;
} else if (marginRight.isAuto()) {
marginLeftValue = marginLeft.calcValue(containerWidth);
marginRightValue = availableSpace - marginLeftValue;
} else {
marginLeftValue = marginLeft.calcValue(containerWidth);
marginRightValue = marginRight.calcValue(containerWidth);
if (containerDirection == RTL)
leftValue = (availableSpace + leftValue) - marginLeftValue - marginRightValue;
}
} else {
marginLeftValue = marginLeft.calcMinValue(containerWidth);
marginRightValue = marginRight.calcMinValue(containerWidth);
const int availableSpace = containerWidth - (marginLeftValue + marginRightValue + bordersPlusPadding);
if (leftIsAuto && widthIsAuto && !rightIsAuto) {
int rightValue = right.calcValue(containerWidth);
int preferredWidth = maxPrefWidth() - bordersPlusPadding;
int preferredMinWidth = minPrefWidth() - bordersPlusPadding;
int availableWidth = availableSpace - rightValue;
widthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);
leftValue = availableSpace - (widthValue + rightValue);
} else if (!leftIsAuto && widthIsAuto && rightIsAuto) {
leftValue = left.calcValue(containerWidth);
int preferredWidth = maxPrefWidth() - bordersPlusPadding;
int preferredMinWidth = minPrefWidth() - bordersPlusPadding;
int availableWidth = availableSpace - leftValue;
widthValue = min(max(preferredMinWidth, availableWidth), preferredWidth);
} else if (leftIsAuto && !width.isAuto() && !rightIsAuto) {
widthValue = calcContentBoxWidth(width.calcValue(containerWidth));
leftValue = availableSpace - (widthValue + right.calcValue(containerWidth));
} else if (!leftIsAuto && widthIsAuto && !rightIsAuto) {
leftValue = left.calcValue(containerWidth);
widthValue = availableSpace - (leftValue + right.calcValue(containerWidth));
} else if (!leftIsAuto&& !widthIsAuto && rightIsAuto) {
leftValue = left.calcValue(containerWidth);
widthValue = calcContentBoxWidth(width.calcValue(containerWidth));
}
}
if (containerBlock->isInline() && containerBlock->style()->direction() == RTL) {
const RenderFlow* flow = static_cast<const RenderFlow*>(containerBlock);
InlineFlowBox* firstLine = flow->firstLineBox();
InlineFlowBox* lastLine = flow->lastLineBox();
if (firstLine && lastLine && firstLine != lastLine) {
xPos = leftValue + marginLeftValue + lastLine->borderLeft() + (lastLine->xPos() - firstLine->xPos());
return;
}
}
xPos = leftValue + marginLeftValue + containerBlock->borderLeft();
}
void RenderBox::calcAbsoluteVertical()
{
if (isReplaced()) {
calcAbsoluteVerticalReplaced();
return;
}
const RenderObject* containerBlock = container();
const int containerHeight = containingBlockHeightForPositioned(containerBlock);
const int bordersPlusPadding = borderTop() + borderBottom() + paddingTop() + paddingBottom();
const Length marginTop = style()->marginTop();
const Length marginBottom = style()->marginBottom();
Length top = style()->top();
Length bottom = style()->bottom();
if (top.isAuto() && bottom.isAuto()) {
int staticTop = staticY() - containerBlock->borderTop();
for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) {
if (!po->isTableRow())
staticTop += po->yPos();
}
top.setValue(Fixed, staticTop);
}
int height;
calcAbsoluteVerticalValues(style()->height(), containerBlock, containerHeight, bordersPlusPadding,
top, bottom, marginTop, marginBottom,
height, m_marginTop, m_marginBottom, m_y);
if (!style()->maxHeight().isUndefined()) {
int maxHeight;
int maxMarginTop;
int maxMarginBottom;
int maxYPos;
calcAbsoluteVerticalValues(style()->maxHeight(), containerBlock, containerHeight, bordersPlusPadding,
top, bottom, marginTop, marginBottom,
maxHeight, maxMarginTop, maxMarginBottom, maxYPos);
if (height > maxHeight) {
height = maxHeight;
m_marginTop = maxMarginTop;
m_marginBottom = maxMarginBottom;
m_y = maxYPos;
}
}
if (!style()->minHeight().isZero()) {
int minHeight;
int minMarginTop;
int minMarginBottom;
int minYPos;
calcAbsoluteVerticalValues(style()->minHeight(), containerBlock, containerHeight, bordersPlusPadding,
top, bottom, marginTop, marginBottom,
minHeight, minMarginTop, minMarginBottom, minYPos);
if (height < minHeight) {
height = minHeight;
m_marginTop = minMarginTop;
m_marginBottom = minMarginBottom;
m_y = minYPos;
}
}
m_height = height + bordersPlusPadding;
}
void RenderBox::calcAbsoluteVerticalValues(Length height, const RenderObject* containerBlock,
const int containerHeight, const int bordersPlusPadding,
const Length top, const Length bottom, const Length marginTop, const Length marginBottom,
int& heightValue, int& marginTopValue, int& marginBottomValue, int& yPos)
{
ASSERT(!(top.isAuto() && bottom.isAuto()));
int contentHeight = m_height - bordersPlusPadding;
int topValue = 0;
bool heightIsAuto = height.isAuto();
bool topIsAuto = top.isAuto();
bool bottomIsAuto = bottom.isAuto();
if (isTable()) {
height.setValue(Fixed, contentHeight);
heightIsAuto = false;
}
if (!topIsAuto && !heightIsAuto && !bottomIsAuto) {
heightValue = calcContentBoxHeight(height.calcValue(containerHeight));
topValue = top.calcValue(containerHeight);
const int availableSpace = containerHeight - (topValue + heightValue + bottom.calcValue(containerHeight) + bordersPlusPadding);
if (marginTop.isAuto() && marginBottom.isAuto()) {
marginTopValue = availableSpace / 2; marginBottomValue = availableSpace - marginTopValue; } else if (marginTop.isAuto()) {
marginBottomValue = marginBottom.calcValue(containerHeight);
marginTopValue = availableSpace - marginBottomValue;
} else if (marginBottom.isAuto()) {
marginTopValue = marginTop.calcValue(containerHeight);
marginBottomValue = availableSpace - marginTopValue;
} else {
marginTopValue = marginTop.calcValue(containerHeight);
marginBottomValue = marginBottom.calcValue(containerHeight);
}
} else {
marginTopValue = marginTop.calcMinValue(containerHeight);
marginBottomValue = marginBottom.calcMinValue(containerHeight);
const int availableSpace = containerHeight - (marginTopValue + marginBottomValue + bordersPlusPadding);
if (topIsAuto && heightIsAuto && !bottomIsAuto) {
heightValue = contentHeight;
topValue = availableSpace - (heightValue + bottom.calcValue(containerHeight));
} else if (!topIsAuto && heightIsAuto && bottomIsAuto) {
topValue = top.calcValue(containerHeight);
heightValue = contentHeight;
} else if (topIsAuto && !heightIsAuto && !bottomIsAuto) {
heightValue = calcContentBoxHeight(height.calcValue(containerHeight));
topValue = availableSpace - (heightValue + bottom.calcValue(containerHeight));
} else if (!topIsAuto && heightIsAuto && !bottomIsAuto) {
topValue = top.calcValue(containerHeight);
heightValue = max(0, availableSpace - (topValue + bottom.calcValue(containerHeight)));
} else if (!topIsAuto && !heightIsAuto && bottomIsAuto) {
heightValue = calcContentBoxHeight(height.calcValue(containerHeight));
topValue = top.calcValue(containerHeight);
}
}
yPos = topValue + marginTopValue + containerBlock->borderTop();
}
void RenderBox::calcAbsoluteHorizontalReplaced()
{
const RenderObject* containerBlock = container();
const int containerWidth = containingBlockWidthForPositioned(containerBlock);
TextDirection containerDirection = (style()->htmlHacks()) ? parent()->style()->direction() : containerBlock->style()->direction();
Length left = style()->left();
Length right = style()->right();
Length marginLeft = style()->marginLeft();
Length marginRight = style()->marginRight();
m_width = calcReplacedWidth() + borderLeft() + borderRight() + paddingLeft() + paddingRight();
const int availableSpace = containerWidth - m_width;
if (left.isAuto() && right.isAuto()) {
if (containerDirection == LTR) {
int staticPosition = staticX() - containerBlock->borderLeft();
for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent())
staticPosition += po->xPos();
left.setValue(Fixed, staticPosition);
} else {
RenderObject* po = parent();
int staticPosition = staticX() + containerWidth + containerBlock->borderRight() - po->width();
for (; po && po != containerBlock; po = po->parent())
staticPosition -= po->xPos();
right.setValue(Fixed, staticPosition);
}
}
if (left.isAuto() || right.isAuto()) {
if (marginLeft.isAuto())
marginLeft.setValue(Fixed, 0);
if (marginRight.isAuto())
marginRight.setValue(Fixed, 0);
}
int leftValue = 0;
int rightValue = 0;
if (marginLeft.isAuto() && marginRight.isAuto()) {
ASSERT(!(left.isAuto() && right.isAuto()));
leftValue = left.calcValue(containerWidth);
rightValue = right.calcValue(containerWidth);
int difference = availableSpace - (leftValue + rightValue);
if (difference > 0) {
m_marginLeft = difference / 2; m_marginRight = difference - m_marginLeft; } else {
if (containerDirection == LTR) {
m_marginLeft = 0;
m_marginRight = difference; } else {
m_marginLeft = difference; m_marginRight = 0;
}
}
} else if (left.isAuto()) {
m_marginLeft = marginLeft.calcValue(containerWidth);
m_marginRight = marginRight.calcValue(containerWidth);
rightValue = right.calcValue(containerWidth);
leftValue = availableSpace - (rightValue + m_marginLeft + m_marginRight);
} else if (right.isAuto()) {
m_marginLeft = marginLeft.calcValue(containerWidth);
m_marginRight = marginRight.calcValue(containerWidth);
leftValue = left.calcValue(containerWidth);
rightValue = availableSpace - (leftValue + m_marginLeft + m_marginRight);
} else if (marginLeft.isAuto()) {
m_marginRight = marginRight.calcValue(containerWidth);
leftValue = left.calcValue(containerWidth);
rightValue = right.calcValue(containerWidth);
m_marginLeft = availableSpace - (leftValue + rightValue + m_marginRight);
} else if (marginRight.isAuto()) {
m_marginLeft = marginLeft.calcValue(containerWidth);
leftValue = left.calcValue(containerWidth);
rightValue = right.calcValue(containerWidth);
m_marginRight = availableSpace - (leftValue + rightValue + m_marginLeft);
} else {
m_marginLeft = marginLeft.calcValue(containerWidth);
m_marginRight = marginRight.calcValue(containerWidth);
rightValue = right.calcValue(containerWidth);
leftValue = left.calcValue(containerWidth);
}
int totalWidth = m_width + leftValue + rightValue + m_marginLeft + m_marginRight;
if (totalWidth > containerWidth && (containerDirection == RTL))
leftValue = containerWidth - (totalWidth - leftValue);
if (containerBlock->isInline() && containerBlock->style()->direction() == RTL) {
const RenderFlow* flow = static_cast<const RenderFlow*>(containerBlock);
InlineFlowBox* firstLine = flow->firstLineBox();
InlineFlowBox* lastLine = flow->lastLineBox();
if (firstLine && lastLine && firstLine != lastLine) {
m_x = leftValue + m_marginLeft + lastLine->borderLeft() + (lastLine->xPos() - firstLine->xPos());
return;
}
}
m_x = leftValue + m_marginLeft + containerBlock->borderLeft();
}
void RenderBox::calcAbsoluteVerticalReplaced()
{
const RenderObject* containerBlock = container();
const int containerHeight = containingBlockHeightForPositioned(containerBlock);
Length top = style()->top();
Length bottom = style()->bottom();
Length marginTop = style()->marginTop();
Length marginBottom = style()->marginBottom();
m_height = calcReplacedHeight() + borderTop() + borderBottom() + paddingTop() + paddingBottom();
const int availableSpace = containerHeight - m_height;
if (top.isAuto() && bottom.isAuto()) {
int staticTop = staticY() - containerBlock->borderTop();
for (RenderObject* po = parent(); po && po != containerBlock; po = po->parent()) {
if (!po->isTableRow())
staticTop += po->yPos();
}
top.setValue(Fixed, staticTop);
}
if (top.isAuto() || bottom.isAuto()) {
if (marginTop.isAuto())
marginTop.setValue(Fixed, 0);
if (marginBottom.isAuto())
marginBottom.setValue(Fixed, 0);
}
int topValue = 0;
int bottomValue = 0;
if (marginTop.isAuto() && marginBottom.isAuto()) {
ASSERT(!(top.isAuto() || bottom.isAuto()));
topValue = top.calcValue(containerHeight);
bottomValue = bottom.calcValue(containerHeight);
int difference = availableSpace - (topValue + bottomValue);
m_marginTop = difference / 2; m_marginBottom = difference - m_marginTop;
} else if (top.isAuto()) {
m_marginTop = marginTop.calcValue(containerHeight);
m_marginBottom = marginBottom.calcValue(containerHeight);
bottomValue = bottom.calcValue(containerHeight);
topValue = availableSpace - (bottomValue + m_marginTop + m_marginBottom);
} else if (bottom.isAuto()) {
m_marginTop = marginTop.calcValue(containerHeight);
m_marginBottom = marginBottom.calcValue(containerHeight);
topValue = top.calcValue(containerHeight);
} else if (marginTop.isAuto()) {
m_marginBottom = marginBottom.calcValue(containerHeight);
topValue = top.calcValue(containerHeight);
bottomValue = bottom.calcValue(containerHeight);
m_marginTop = availableSpace - (topValue + bottomValue + m_marginBottom);
} else if (marginBottom.isAuto()) {
m_marginTop = marginTop.calcValue(containerHeight);
topValue = top.calcValue(containerHeight);
bottomValue = bottom.calcValue(containerHeight);
m_marginBottom = availableSpace - (topValue + bottomValue + m_marginTop);
} else {
m_marginTop = marginTop.calcValue(containerHeight);
m_marginBottom = marginBottom.calcValue(containerHeight);
topValue = top.calcValue(containerHeight);
}
m_y = topValue + m_marginTop + containerBlock->borderTop();
}
IntRect RenderBox::caretRect(int offset, EAffinity affinity, int* extraWidthToEndOfLine)
{
const int caretWidth = 1;
IntRect rect(xPos(), yPos(), caretWidth, m_height);
if (offset)
rect.move(IntSize(m_width - caretWidth, 0));
if (InlineBox* box = inlineBoxWrapper()) {
RootInlineBox* rootBox = box->root();
int top = rootBox->topOverflow();
rect.setY(top);
rect.setHeight(rootBox->bottomOverflow() - top);
}
int fontHeight = style()->font().height();
if (fontHeight > rect.height() || !isReplaced() && !isTable())
rect.setHeight(fontHeight);
RenderObject* cb = containingBlock();
int cbx, cby;
if (!cb || !cb->absolutePosition(cbx, cby))
return IntRect();
if (extraWidthToEndOfLine)
*extraWidthToEndOfLine = xPos() + m_width - rect.right();
rect.move(cbx, cby);
return rect;
}
int RenderBox::lowestPosition(bool includeOverflowInterior, bool includeSelf) const
{
if (!includeSelf || !m_width)
return 0;
int bottom = m_height;
if (includeSelf && isRelPositioned())
bottom += relativePositionOffsetY();
return bottom;
}
int RenderBox::rightmostPosition(bool includeOverflowInterior, bool includeSelf) const
{
if (!includeSelf || !m_height)
return 0;
int right = m_width;
if (includeSelf && isRelPositioned())
right += relativePositionOffsetX();
return right;
}
int RenderBox::leftmostPosition(bool includeOverflowInterior, bool includeSelf) const
{
if (!includeSelf || !m_height)
return m_width;
int left = 0;
if (includeSelf && isRelPositioned())
left += relativePositionOffsetX();
return left;
}
}