#include "config.h"
#include "LayoutState.h"
#include "ColumnInfo.h"
#include "RenderArena.h"
#include "RenderFlowThread.h"
#include "RenderInline.h"
#include "RenderLayer.h"
#include "RenderView.h"
namespace WebCore {
LayoutState::LayoutState(LayoutState* prev, RenderBox* renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged, ColumnInfo* columnInfo)
: m_columnInfo(columnInfo)
, m_lineGrid(0)
, m_next(prev)
#if ENABLE(CSS_SHAPES)
, m_shapeInsideInfo(0)
#endif
#ifndef NDEBUG
, m_renderer(renderer)
#endif
{
ASSERT(m_next);
bool fixed = renderer->isOutOfFlowPositioned() && renderer->style()->position() == FixedPosition;
if (fixed) {
FloatPoint fixedOffset = renderer->view()->localToAbsolute(FloatPoint(), IsFixed);
m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y()) + offset;
} else
m_paintOffset = prev->m_paintOffset + offset;
if (renderer->isOutOfFlowPositioned() && !fixed) {
if (RenderObject* container = renderer->container()) {
if (container->isInFlowPositioned() && container->isRenderInline())
m_paintOffset += toRenderInline(container)->offsetForInFlowPositionedInline(renderer);
}
}
m_layoutOffset = m_paintOffset;
if (renderer->hasPaintOffset() && renderer->hasLayer())
m_paintOffset += renderer->layer()->paintOffset();
m_clipped = !fixed && prev->m_clipped;
if (m_clipped)
m_clipRect = prev->m_clipRect;
if (renderer->hasOverflowClip()) {
LayoutRect clipRect(toPoint(m_paintOffset) + renderer->view()->layoutDelta(), renderer->cachedSizeForOverflowClip());
if (m_clipped)
m_clipRect.intersect(clipRect);
else {
m_clipRect = clipRect;
m_clipped = true;
}
m_paintOffset -= renderer->scrolledContentOffset();
}
if (pageLogicalHeight || m_columnInfo || renderer->isRenderFlowThread()) {
m_pageLogicalHeight = pageLogicalHeight;
bool isFlipped = renderer->style()->isFlippedBlocksWritingMode();
m_pageOffset = LayoutSize(m_layoutOffset.width() + (!isFlipped ? renderer->borderLeft() + renderer->paddingLeft() : renderer->borderRight() + renderer->paddingRight()),
m_layoutOffset.height() + (!isFlipped ? renderer->borderTop() + renderer->paddingTop() : renderer->borderBottom() + renderer->paddingBottom()));
m_pageLogicalHeightChanged = pageLogicalHeightChanged;
} else {
m_pageLogicalHeight = m_next->m_pageLogicalHeight;
m_pageLogicalHeightChanged = m_next->m_pageLogicalHeightChanged;
m_pageOffset = m_next->m_pageOffset;
if (renderer->isUnsplittableForPagination())
m_pageLogicalHeight = 0;
}
propagateLineGridInfo(renderer);
if (!m_columnInfo)
m_columnInfo = m_next->m_columnInfo;
#if ENABLE(CSS_SHAPES)
if (renderer->isRenderBlock()) {
const RenderBlock* renderBlock = toRenderBlock(renderer);
m_shapeInsideInfo = renderBlock->shapeInsideInfo();
if (!m_shapeInsideInfo && m_next->m_shapeInsideInfo && renderBlock->allowsShapeInsideInfoSharing())
m_shapeInsideInfo = m_next->m_shapeInsideInfo;
}
#endif
m_layoutDelta = m_next->m_layoutDelta;
#if !ASSERT_DISABLED && ENABLE(SATURATED_LAYOUT_ARITHMETIC)
m_layoutDeltaXSaturated = m_next->m_layoutDeltaXSaturated;
m_layoutDeltaYSaturated = m_next->m_layoutDeltaYSaturated;
#endif
m_isPaginated = m_pageLogicalHeight || m_columnInfo || renderer->isRenderFlowThread();
if (lineGrid() && renderer->hasColumns() && renderer->style()->hasInlineColumnAxis())
computeLineGridPaginationOrigin(renderer);
if (renderer->style()->lineGrid() != RenderStyle::initialLineGrid() && renderer->isBlockFlow())
establishLineGrid(toRenderBlock(renderer));
}
LayoutState::LayoutState(RenderObject* root)
: m_clipped(false)
, m_isPaginated(false)
, m_pageLogicalHeightChanged(false)
#if !ASSERT_DISABLED && ENABLE(SATURATED_LAYOUT_ARITHMETIC)
, m_layoutDeltaXSaturated(false)
, m_layoutDeltaYSaturated(false)
#endif
, m_columnInfo(0)
, m_lineGrid(0)
, m_next(0)
#if ENABLE(CSS_SHAPES)
, m_shapeInsideInfo(0)
#endif
, m_pageLogicalHeight(0)
#ifndef NDEBUG
, m_renderer(root)
#endif
{
RenderObject* container = root->container();
FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), UseTransforms);
m_paintOffset = LayoutSize(absContentPoint.x(), absContentPoint.y());
if (container->hasOverflowClip()) {
m_clipped = true;
RenderBox* containerBox = toRenderBox(container);
m_clipRect = LayoutRect(toPoint(m_paintOffset), containerBox->cachedSizeForOverflowClip());
m_paintOffset -= containerBox->scrolledContentOffset();
}
}
#ifndef NDEBUG
static bool inLayoutStateDestroy;
#endif
void LayoutState::destroy(RenderArena* renderArena)
{
#ifndef NDEBUG
inLayoutStateDestroy = true;
#endif
delete this;
#ifndef NDEBUG
inLayoutStateDestroy = false;
#endif
renderArena->free(*(size_t*)this, this);
}
void* LayoutState::operator new(size_t sz, RenderArena* renderArena)
{
return renderArena->allocate(sz);
}
void LayoutState::operator delete(void* ptr, size_t sz)
{
ASSERT(inLayoutStateDestroy);
*(size_t*)ptr = sz;
}
void LayoutState::clearPaginationInformation()
{
m_pageLogicalHeight = m_next->m_pageLogicalHeight;
m_pageOffset = m_next->m_pageOffset;
m_columnInfo = m_next->m_columnInfo;
}
LayoutUnit LayoutState::pageLogicalOffset(RenderBox* child, LayoutUnit childLogicalOffset) const
{
if (child->isHorizontalWritingMode())
return m_layoutOffset.height() + childLogicalOffset - m_pageOffset.height();
return m_layoutOffset.width() + childLogicalOffset - m_pageOffset.width();
}
void LayoutState::addForcedColumnBreak(RenderBox* child, LayoutUnit childLogicalOffset)
{
if (!m_columnInfo || m_columnInfo->columnHeight())
return;
m_columnInfo->addForcedBreak(pageLogicalOffset(child, childLogicalOffset));
}
void LayoutState::propagateLineGridInfo(RenderBox* renderer)
{
if (!m_next || renderer->isUnsplittableForPagination())
return;
m_lineGrid = m_next->m_lineGrid;
m_lineGridOffset = m_next->m_lineGridOffset;
m_lineGridPaginationOrigin = m_next->m_lineGridPaginationOrigin;
}
void LayoutState::establishLineGrid(RenderBlock* block)
{
if (m_lineGrid) {
if (m_lineGrid->style()->lineGrid() == block->style()->lineGrid())
return;
RenderBlock* currentGrid = m_lineGrid;
for (LayoutState* currentState = m_next; currentState; currentState = currentState->m_next) {
if (currentState->m_lineGrid == currentGrid)
continue;
currentGrid = currentState->m_lineGrid;
if (!currentGrid)
break;
if (currentGrid->style()->lineGrid() == block->style()->lineGrid()) {
m_lineGrid = currentGrid;
m_lineGridOffset = currentState->m_lineGridOffset;
return;
}
}
}
m_lineGrid = block;
m_lineGridOffset = m_layoutOffset;
}
void LayoutState::computeLineGridPaginationOrigin(RenderBox* renderer)
{
if (!lineGrid() || lineGrid()->style()->writingMode() != renderer->style()->writingMode())
return;
RootInlineBox* lineGridBox = lineGrid()->lineGridBox();
if (!lineGridBox)
return;
bool isHorizontalWritingMode = lineGrid()->isHorizontalWritingMode();
LayoutUnit lineGridBlockOffset = isHorizontalWritingMode ? lineGridOffset().height() : lineGridOffset().width();
LayoutUnit gridLineHeight = lineGridBox->lineBottomWithLeading() - lineGridBox->lineTopWithLeading();
if (!gridLineHeight)
return;
LayoutUnit firstLineTopWithLeading = lineGridBlockOffset + lineGridBox->lineTopWithLeading();
if (isPaginated() && pageLogicalHeight()) {
LayoutUnit pageLogicalTop = renderer->isHorizontalWritingMode() ? m_pageOffset.height() : m_pageOffset.width();
if (pageLogicalTop > firstLineTopWithLeading) {
LayoutUnit remainder = roundToInt(pageLogicalTop - firstLineTopWithLeading) % roundToInt(gridLineHeight);
LayoutUnit paginationDelta = gridLineHeight - remainder;
if (isHorizontalWritingMode)
m_lineGridPaginationOrigin.setHeight(paginationDelta);
else
m_lineGridPaginationOrigin.setWidth(paginationDelta);
}
}
}
}