Changeset 246482 in webkit

Timestamp:

Jun 16, 2019 1:15:02 PM (5 years ago)

Author:

Alan Bujtas

Message:

[LFC][Floats] Add bottom value to FloatingState::Constraints
​https://bugs.webkit.org/show_bug.cgi?id=198889
<rdar://problem/51776730>

Reviewed by Antti Koivisto.

Constraints::left/right->y indicates where this particular constrain ends. This is going to be used by inline layout to figure where
the next line should go (vertical position).

• layout/floats/FloatingState.cpp:

(WebCore::Layout::FloatingState::constraints const):

• layout/floats/FloatingState.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/LayoutUnits.h (modified) (2 diffs)
• layout/blockformatting/BlockFormattingContext.cpp (modified) (1 diff)
• layout/floats/FloatingState.cpp (modified) (3 diffs)
• layout/floats/FloatingState.h (modified) (1 diff)
• layout/inlineformatting/InlineFormattingContextLineLayout.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-06-16  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC][Floats] Add bottom value to FloatingState::Constraints
+        https://bugs.webkit.org/show_bug.cgi?id=198889
+        <rdar://problem/51776730>
+
+        Reviewed by Antti Koivisto.
+
+        Constraints::left/right->y indicates where this particular constrain ends. This is going to be used by inline layout to figure where
+        the next line should go (vertical position).
+
+        * layout/floats/FloatingState.cpp:
+        (WebCore::Layout::FloatingState::constraints const):
+        * layout/floats/FloatingState.h:
+
 2019-06-16  Zalan Bujtas  <zalan@apple.com>
 

trunk/Source/WebCore/layout/LayoutUnits.h

@@ -60 +60 @@
     Point(LayoutUnit, LayoutUnit);
     Point(LayoutPoint);
+    void move(LayoutSize);
     void moveBy(LayoutPoint);
     operator LayoutPoint() const { return { x, y }; }
@@ -78 +79 @@
     , y(y)
 {
+}
+
+inline void Point::move(LayoutSize offset)
+{
+    x += offset.width();
+    y += offset.height();
 }
 

trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp

@@ -149 +149 @@
 
     // Shrink the available space if the floats are actually intruding at this vertical position.
-    availableWidth -= (std::max<LayoutUnit>(0, constraints.left.valueOr(PositionInContextRoot { 0 }) - containingBlockContentBoxLeft)
-        + std::max<LayoutUnit>(0, containingBlockContentBoxRight - constraints.right.valueOr(PositionInContextRoot { containingBlockContentBoxRight })));
+    if (constraints.left)
+        availableWidth -= std::max<LayoutUnit>(0, constraints.left->x - containingBlockContentBoxLeft);
+    if (constraints.right)
+        availableWidth -= std::max<LayoutUnit>(0, containingBlockContentBoxRight - constraints.right->x);
     return availableWidth;
 }

trunk/Source/WebCore/layout/floats/FloatingState.cpp

@@ -120 +120 @@
     auto coordinateMappingIsRequired = &root() != &formattingContextRoot;
     auto adjustedPosition = Point { 0, verticalPosition };
-
-    if (coordinateMappingIsRequired)
+    LayoutSize adjustingDelta;
+
+    if (coordinateMappingIsRequired) {
         adjustedPosition = FormattingContext::mapPointToAncestor(m_layoutState, adjustedPosition, downcast<Container>(formattingContextRoot), downcast<Container>(root()));
+        adjustingDelta = { adjustedPosition.x, adjustedPosition.y - verticalPosition };
+    }
 
     Constraints constraints;
@@ -139 +142 @@
 
         if (floatItem.isLeftPositioned())
-            constraints.left = PositionInContextRoot { rect.right() };
+            constraints.left = PointInContextRoot { rect.right(), rect.bottom() };
         else
-            constraints.right = PositionInContextRoot { rect.left() };
+            constraints.right = PointInContextRoot { rect.left(), rect.bottom() };
 
         if (constraints.left && constraints.right)
@@ -149 +152 @@
     if (coordinateMappingIsRequired) {
         if (constraints.left)
-            constraints.left = PositionInContextRoot { *constraints.left - adjustedPosition.x };
+            constraints.left->move(-adjustingDelta);
 
         if (constraints.right)
-            constraints.right = PositionInContextRoot { *constraints.right - adjustedPosition.x };
-    }
-
+            constraints.right->move(-adjustingDelta);
+    }
     return constraints;
 }

trunk/Source/WebCore/layout/floats/FloatingState.h

@@ -61 +61 @@
 
     struct Constraints {
-        Optional<PositionInContextRoot> left;
-        Optional<PositionInContextRoot> right;
+        Optional<PointInContextRoot> left;
+        Optional<PointInContextRoot> right;
     };
     Constraints constraints(PositionInContextRoot verticalPosition, const Box& formattingContextRoot) const;

trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp

@@ -231 +231 @@
         auto floatConstraints = m_floatingState.constraints({ lineLogicalTop }, m_formattingRoot);
         // Check if these constraints actually put limitation on the line.
-        if (floatConstraints.left && *floatConstraints.left <= formattingRootDisplayBox.contentBoxLeft())
+        if (floatConstraints.left && floatConstraints.left->x <= formattingRootDisplayBox.contentBoxLeft())
             floatConstraints.left = { };
 
-        if (floatConstraints.right && *floatConstraints.right >= formattingRootDisplayBox.contentBoxRight())
+        if (floatConstraints.right && floatConstraints.right->x >= formattingRootDisplayBox.contentBoxRight())
             floatConstraints.right = { };
 
         if (floatConstraints.left && floatConstraints.right) {
-            ASSERT(*floatConstraints.left < *floatConstraints.right);
-            availableWidth = *floatConstraints.right - *floatConstraints.left;
-            lineLogicalLeft = *floatConstraints.left;
+            ASSERT(floatConstraints.left->x < floatConstraints.right->x);
+            availableWidth = floatConstraints.right->x - floatConstraints.left->x;
+            lineLogicalLeft = floatConstraints.left->x;
         } else if (floatConstraints.left) {
-            ASSERT(*floatConstraints.left > lineLogicalLeft);
-            availableWidth -= (*floatConstraints.left - lineLogicalLeft);
-            lineLogicalLeft = *floatConstraints.left;
+            ASSERT(floatConstraints.left->x > lineLogicalLeft);
+            availableWidth -= (floatConstraints.left->x - lineLogicalLeft);
+            lineLogicalLeft = floatConstraints.left->x;
         } else if (floatConstraints.right) {
-            ASSERT(*floatConstraints.right > lineLogicalLeft);
-            availableWidth = *floatConstraints.right - lineLogicalLeft;
+            ASSERT(floatConstraints.right->x > lineLogicalLeft);
+            availableWidth = floatConstraints.right->x - lineLogicalLeft;
         }
         lineHorizontalConstraint.availableLogicalWidth = availableWidth;