Skip to content

Commit

Permalink
[IFC][Geometry] Remove BoxGeometry's logical/visual conversion helpers
Browse files Browse the repository at this point in the history 
https://bugs.webkit.org/show_bug.cgi?id=267202

Reviewed by Antti Koivisto.

Since BoxGeometry is supposed to be always logical, let's not have visual related helpers on it.

* Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp:
(WebCore::LayoutIntegration::toMarginAndBorderBoxVisualRect):
(WebCore::LayoutIntegration::LineLayout::updateRenderTreePositions):
* Source/WebCore/layout/layouttree/LayoutBoxGeometry.cpp:
(WebCore::Layout::BoxGeometry::toVisualGeometry const): Deleted.
(WebCore::Layout::BoxGeometry::toLogicalGeometry const): Deleted.
* Source/WebCore/layout/layouttree/LayoutBoxGeometry.h:

Canonical link: https://commits.webkit.org/272815@main
  • Loading branch information
@alanbaradlay
alanbaradlay committed Jan 9, 2024
1 parent 2d83031 commit 4c2711d
Show file tree
Hide file tree
Showing 3 changed files with 55 additions and 122 deletions.
69 changes: 55 additions & 14 deletions Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,6 +64,54 @@ namespace LayoutIntegration {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(LayoutIntegration_LineLayout);

static inline std::pair<LayoutRect, LayoutRect> toMarginAndBorderBoxVisualRect(const Layout::BoxGeometry& logicalGeometry, LayoutUnit containerLogicalWidth, WritingMode writingMode, bool isLeftToRightDirection)
{
auto isFlippedBlocksWritingMode = WebCore::isFlippedWritingMode(writingMode);
auto isHorizontalWritingMode = WebCore::isHorizontalWritingMode(writingMode);

auto borderBoxLogicalRect = Layout::BoxGeometry::borderBoxRect(logicalGeometry);
auto horizontalMargin = Layout::BoxGeometry::HorizontalMargin { logicalGeometry.marginStart(), logicalGeometry.marginEnd() };
auto verticalMargin = Layout::BoxGeometry::VerticalMargin { logicalGeometry.marginBefore(), logicalGeometry.marginAfter() };

auto flipMarginsIfApplicable = [&] {
if (isHorizontalWritingMode && isLeftToRightDirection && !isFlippedBlocksWritingMode)
return;

if (!isHorizontalWritingMode) {
auto logicalHorizontalMargin = horizontalMargin;
horizontalMargin = !isFlippedBlocksWritingMode ? Layout::BoxGeometry::HorizontalMargin { verticalMargin.after, verticalMargin.before } : Layout::BoxGeometry::HorizontalMargin { verticalMargin.before, verticalMargin.after };
verticalMargin = { logicalHorizontalMargin.start, logicalHorizontalMargin.end };
}
if (!isLeftToRightDirection) {
if (isHorizontalWritingMode)
horizontalMargin = { horizontalMargin.end, horizontalMargin.start };
else
verticalMargin = { verticalMargin.after, verticalMargin.before };
}
};
flipMarginsIfApplicable();

auto borderBoxVisualTopLeft = LayoutPoint { };
auto borderBoxLeft = isLeftToRightDirection ? borderBoxLogicalRect.left() : containerLogicalWidth - (borderBoxLogicalRect.left() + borderBoxLogicalRect.width());
if (isHorizontalWritingMode)
borderBoxVisualTopLeft = { borderBoxLeft, borderBoxLogicalRect.top() };
else {
auto marginBoxVisualLeft = borderBoxLogicalRect.top() - logicalGeometry.marginBefore();
auto marginBoxVisualTop = borderBoxLeft - logicalGeometry.marginStart();
if (isLeftToRightDirection)
borderBoxVisualTopLeft = { marginBoxVisualLeft + horizontalMargin.start, marginBoxVisualTop + verticalMargin.before };
else
borderBoxVisualTopLeft = { marginBoxVisualLeft + horizontalMargin.start, marginBoxVisualTop + verticalMargin.after };
}

auto borderBoxVisualRect = LayoutRect { borderBoxVisualTopLeft, isHorizontalWritingMode ? borderBoxLogicalRect.size() : borderBoxLogicalRect.size().transposedSize() };
auto marginBoxVisualRect = borderBoxVisualRect;

marginBoxVisualRect.move(-horizontalMargin.start, -verticalMargin.before);
marginBoxVisualRect.expand(horizontalMargin.start + horizontalMargin.end, verticalMargin.before + verticalMargin.after);
return { marginBoxVisualRect, borderBoxVisualRect };
}

LineLayout::LineLayout(RenderBlockFlow& flow)
: m_boxTree(flow)
, m_layoutState(flow.view().layoutState())
Expand Down Expand Up @@ -395,39 +443,32 @@ void LineLayout::updateRenderTreePositions(const Vector<LineAdjustment>& lineAdj
}
}

// FIXME: Loop through the floating state?
for (auto& renderObject : m_boxTree.renderers()) {
auto& layoutBox = *renderObject->layoutBox();
if (!layoutBox.isFloatingPositioned() && !layoutBox.isOutOfFlowPositioned())
continue;
if (layoutBox.isLineBreakBox())
continue;
auto& renderer = downcast<RenderBox>(m_boxTree.rendererForLayoutBox(layoutBox));
// FIXME: Figure out if this should all be visual geometry at this point.
auto& logicalGeometry = layoutState().geometryForBox(layoutBox);

if (layoutBox.isFloatingPositioned()) {
auto& floatingObject = flow().insertFloatingObjectForIFC(renderer);

ASSERT(m_inlineContentConstraints);
auto rootBorderBoxWidth = m_inlineContentConstraints->visualLeft() + m_inlineContentConstraints->horizontal().logicalWidth + m_inlineContentConstraints->horizontal().logicalLeft;

auto visualGeometry = logicalGeometry.toVisualGeometry(writingMode, isLeftToRightPlacedFloatsInlineDirection, rootBorderBoxWidth);
auto visualMarginBoxRect = LayoutRect { Layout::BoxGeometry::marginBoxRect(visualGeometry) };
auto visualBorderBoxRect = LayoutRect { Layout::BoxGeometry::borderBoxRect(visualGeometry) };
auto containerLogicalWidth = m_inlineContentConstraints->visualLeft() + m_inlineContentConstraints->horizontal().logicalWidth + m_inlineContentConstraints->horizontal().logicalLeft;
auto [marginBoxVisualRect, borderBoxVisualRect] = toMarginAndBorderBoxVisualRect(logicalGeometry, containerLogicalWidth, writingMode, isLeftToRightPlacedFloatsInlineDirection);

auto paginationOffset = floatPaginationOffsetMap.getOptional(layoutBox);
if (paginationOffset) {
visualMarginBoxRect.move(*paginationOffset);
visualBorderBoxRect.move(*paginationOffset);
marginBoxVisualRect.move(*paginationOffset);
borderBoxVisualRect.move(*paginationOffset);
}

floatingObject.setFrameRect(visualMarginBoxRect);
floatingObject.setMarginOffset({ visualGeometry.marginStart(), visualGeometry.marginBefore() });
floatingObject.setFrameRect(marginBoxVisualRect);
floatingObject.setMarginOffset({ borderBoxVisualRect.x() - marginBoxVisualRect.x(), borderBoxVisualRect.y() - marginBoxVisualRect.y() });
floatingObject.setIsPlaced(true);

auto oldRect = renderer.frameRect();
renderer.setLocation(visualBorderBoxRect.location());
renderer.setLocation(borderBoxVisualRect.location());

if (renderer.checkForRepaintDuringLayout()) {
auto hasMoved = oldRect.location() != renderer.location();
Expand Down
105 changes: 0 additions & 105 deletions Source/WebCore/layout/layouttree/LayoutBoxGeometry.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -103,111 +103,6 @@ Rect BoxGeometry::contentBox() const
return contentBox;
}

BoxGeometry BoxGeometry::toVisualGeometry(WritingMode writingMode, bool isLeftToRightDirection, LayoutUnit containerLogicalWidth) const
{
auto isHorizontalWritingMode = WebCore::isHorizontalWritingMode(writingMode);
auto isFlippedBlocksWritingMode = WebCore::isFlippedWritingMode(writingMode);

if (isHorizontalWritingMode && isLeftToRightDirection)
return *this;

auto visualGeometry = *this;
if (isHorizontalWritingMode) {
// Horizontal flip.
visualGeometry.m_horizontalMargin = { m_horizontalMargin.end, m_horizontalMargin.start };
visualGeometry.m_border.horizontal = { m_border.horizontal.right, m_border.horizontal.left };
if (m_padding)
visualGeometry.m_padding->horizontal = { m_padding->horizontal.right, m_padding->horizontal.left };

visualGeometry.m_topLeft.setX(containerLogicalWidth - (m_topLeft.x() + borderBoxWidth()));
return visualGeometry;
}

// Vertical flip.
visualGeometry.m_contentBoxWidth = m_contentBoxHeight;
visualGeometry.m_contentBoxHeight = m_contentBoxWidth;

visualGeometry.m_horizontalMargin = !isFlippedBlocksWritingMode ? HorizontalMargin { m_verticalMargin.after, m_verticalMargin.before } : HorizontalMargin { m_verticalMargin.before, m_verticalMargin.after };
visualGeometry.m_verticalMargin = { m_horizontalMargin.start, m_horizontalMargin.end };

auto left = isLeftToRightDirection ? m_topLeft.x() : containerLogicalWidth - (m_topLeft.x() + borderBoxWidth());
auto marginBoxOffset = LayoutSize { left - m_horizontalMargin.start, m_topLeft.y() - m_verticalMargin.before }.transposedSize();
visualGeometry.m_topLeft = { visualGeometry.m_horizontalMargin.start, visualGeometry.m_verticalMargin.before };
visualGeometry.m_topLeft.move(marginBoxOffset);

visualGeometry.m_border = { { m_border.vertical.bottom, m_border.vertical.top }, { m_border.horizontal.left, m_border.horizontal.right } };

if (m_padding)
visualGeometry.m_padding = Layout::Edges { { m_padding->vertical.bottom, m_padding->vertical.top }, { m_padding->horizontal.left, m_padding->horizontal.right } };

visualGeometry.m_verticalSpaceForScrollbar = m_horizontalSpaceForScrollbar;
visualGeometry.m_horizontalSpaceForScrollbar = m_verticalSpaceForScrollbar;

return visualGeometry;
}

BoxGeometry BoxGeometry::toLogicalGeometry(WritingMode writingMode, bool isLeftToRightInlineDirection, LayoutUnit containerLogicalWidth) const
{
auto isHorizontalWritingMode = WebCore::isHorizontalWritingMode(writingMode);
auto isFlippedBlocksWritingMode = WebCore::isFlippedWritingMode(writingMode);

if (isHorizontalWritingMode && !isFlippedBlocksWritingMode && isLeftToRightInlineDirection)
return *this;

auto logicalGeometry = *this;
if (isHorizontalWritingMode) {

if (!isLeftToRightInlineDirection) {
logicalGeometry.m_horizontalMargin = { m_horizontalMargin.end, m_horizontalMargin.start };
logicalGeometry.m_border.horizontal = { m_border.horizontal.right, m_border.horizontal.left };
if (m_padding)
logicalGeometry.m_padding->horizontal = { m_padding->horizontal.right, m_padding->horizontal.left };
logicalGeometry.m_topLeft.setX(containerLogicalWidth - BoxGeometry::borderBoxRect(*this).right());
}

// This is regular horizontal-tb with rtl content.
if (!isFlippedBlocksWritingMode)
return logicalGeometry;

// horizontal-bt with ltr/rtl content.
logicalGeometry.m_verticalMargin = { m_verticalMargin.after, m_verticalMargin.before };
logicalGeometry.m_border.vertical = { m_border.vertical.bottom, m_border.vertical.top };
if (m_padding)
logicalGeometry.m_padding->vertical = { m_padding->vertical.bottom, m_padding->vertical.top };
return logicalGeometry;
}

// vertical-lr/rl with inline direction of ltr/rtl.
logicalGeometry.m_contentBoxWidth = m_contentBoxHeight;
logicalGeometry.m_contentBoxHeight = m_contentBoxWidth;
logicalGeometry.m_horizontalSpaceForScrollbar = m_verticalSpaceForScrollbar;
logicalGeometry.m_verticalSpaceForScrollbar = m_horizontalSpaceForScrollbar;

logicalGeometry.m_horizontalMargin = { m_verticalMargin.before, m_verticalMargin.after };
logicalGeometry.m_border.horizontal = { m_border.vertical.top, m_border.vertical.bottom };
if (m_padding)
logicalGeometry.m_padding->horizontal = { m_padding->vertical.top, m_padding->vertical.bottom };

// Flip inline direction now that we have the logical horizontal decoration.
if (!isLeftToRightInlineDirection) {
logicalGeometry.m_horizontalMargin = { logicalGeometry.m_horizontalMargin.end, logicalGeometry.m_horizontalMargin.start };
logicalGeometry.m_border.horizontal = { logicalGeometry.m_border.horizontal.right, logicalGeometry.m_border.horizontal.left };
if (logicalGeometry.m_padding)
logicalGeometry.m_padding->horizontal = { logicalGeometry.m_padding->horizontal.right, logicalGeometry.m_padding->horizontal.left };
}

// Flip vertical decoration depending on whether the block direction is left to right or right to left.
logicalGeometry.m_verticalMargin = !isFlippedBlocksWritingMode ? VerticalMargin { m_horizontalMargin.start, m_horizontalMargin.end } : VerticalMargin { m_horizontalMargin.end, m_horizontalMargin.start };
logicalGeometry.m_border.vertical = !isFlippedBlocksWritingMode ? VerticalEdges { m_border.horizontal.left, m_border.horizontal.right } : VerticalEdges { m_border.horizontal.right, m_border.horizontal.left };
if (m_padding)
logicalGeometry.m_padding->vertical = !isFlippedBlocksWritingMode ? VerticalEdges { m_padding->horizontal.left, m_padding->horizontal.right } : VerticalEdges { m_padding->horizontal.right, m_padding->horizontal.left };

logicalGeometry.m_topLeft = m_topLeft.transposedPoint();
if (!isLeftToRightInlineDirection)
logicalGeometry.m_topLeft.setX(containerLogicalWidth - BoxGeometry::borderBoxRect(*this).bottom());
return logicalGeometry;
}

}
}

3 changes: 0 additions & 3 deletions Source/WebCore/layout/layouttree/LayoutBoxGeometry.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -153,9 +153,6 @@ class BoxGeometry {
void setVerticalSpaceForScrollbar(LayoutUnit scrollbarHeight) { m_verticalSpaceForScrollbar = scrollbarHeight; }
void setHorizontalSpaceForScrollbar(LayoutUnit scrollbarWidth) { m_horizontalSpaceForScrollbar = scrollbarWidth; }

BoxGeometry toVisualGeometry(WritingMode, bool isLeftToRightInlineDirection, LayoutUnit containerLogicalWidth) const;
BoxGeometry toLogicalGeometry(WritingMode, bool isLeftToRightInlineDirection, LayoutUnit containerLogicalWidth) const;

private:
LayoutUnit top() const;
LayoutUnit left() const;
Expand Down

0 comments on commit 4c2711d

Please sign in to comment.