#include "config.h"
#include "LayoutState.h"
#include "RenderFlowThread.h"
#include "RenderInline.h"
#include "RenderLayer.h"
#include "RenderMultiColumnFlowThread.h"
#include "RenderView.h"
namespace WebCore {
LayoutState::LayoutState(std::unique_ptr<LayoutState> next, RenderBox* renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged)
: m_lineGrid(0)
, m_next(WTF::move(next))
#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 = m_next->m_paintOffset + offset;
if (renderer->isOutOfFlowPositioned() && !fixed) {
if (RenderElement* container = renderer->container()) {
if (container->isInFlowPositioned() && container->isRenderInline())
m_paintOffset += toRenderInline(container)->offsetForInFlowPositionedInline(renderer);
}
}
m_layoutOffset = m_paintOffset;
if (renderer->isInFlowPositioned() && renderer->hasLayer())
m_paintOffset += renderer->layer()->offsetForInFlowPosition();
m_clipped = !fixed && m_next->m_clipped;
if (m_clipped)
m_clipRect = m_next->m_clipRect;
if (renderer->hasOverflowClip()) {
LayoutRect clipRect(toLayoutPoint(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 || 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;
m_isPaginated = true;
} 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;
m_isPaginated = false;
} else
m_isPaginated = m_pageLogicalHeight || renderer->flowThreadContainingBlock();
}
propagateLineGridInfo(renderer);
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
if (lineGrid() && (lineGrid()->style().writingMode() == renderer->style().writingMode()) && renderer->isRenderMultiColumnFlowThread())
toRenderMultiColumnFlowThread(renderer)->computeLineGridPaginationOrigin(*this);
if (renderer->style().lineGrid() != RenderStyle::initialLineGrid() && renderer->isRenderBlockFlow())
establishLineGrid(toRenderBlockFlow(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_lineGrid(0)
, m_pageLogicalHeight(0)
#ifndef NDEBUG
, m_renderer(&root)
#endif
{
RenderElement* 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(toLayoutPoint(m_paintOffset), containerBox->cachedSizeForOverflowClip());
m_paintOffset -= containerBox->scrolledContentOffset();
}
}
void LayoutState::clearPaginationInformation()
{
m_pageLogicalHeight = m_next->m_pageLogicalHeight;
m_pageOffset = m_next->m_pageOffset;
}
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::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(RenderBlockFlow* block)
{
if (m_lineGrid) {
if (m_lineGrid->style().lineGrid() == block->style().lineGrid())
return;
RenderBlockFlow* currentGrid = m_lineGrid;
for (LayoutState* currentState = m_next.get(); currentState; currentState = currentState->m_next.get()) {
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;
}
}