Changeset 246457 in webkit

Timestamp:

Jun 15, 2019 7:03:23 AM (5 years ago)

Author:

Alan Bujtas

Message:

[LFC][IFC] Add support for vertical-align: top and bottom
​https://bugs.webkit.org/show_bug.cgi?id=198697
<rdar://problem/51556188>

Reviewed by Antti Koivisto.

Use the layout box's vertical alignment to adjust line baseline and height and set the run's logical top when the line is being closed.

• layout/inlineformatting/InlineLine.cpp:

(WebCore::Layout::Line::isVisuallyEmpty const):
(WebCore::Layout::Line::close):
(WebCore::Layout::Line::appendInlineContainerStart):
(WebCore::Layout::Line::appendTextContent):
(WebCore::Layout::Line::appendNonReplacedInlineBox):
(WebCore::Layout::Line::appendHardLineBreak):
(WebCore::Layout::Line::adjustBaselineAndLineHeight):
(WebCore::Layout::Line::inlineItemHeight const):
(WebCore::Layout::Line::Content::isVisuallyEmpty const): Deleted.

• layout/inlineformatting/InlineLine.h:

(WebCore::Layout::Line::Content::isVisuallyEmpty const):
(WebCore::Layout::Line::Content::setIsVisuallyEmpty):
(WebCore::Layout::Line::hasContent const):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/inlineformatting/InlineLine.cpp (modified) (8 diffs)
• layout/inlineformatting/InlineLine.h (modified) (6 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-06-15  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC][IFC] Add support for vertical-align: top and bottom
+        https://bugs.webkit.org/show_bug.cgi?id=198697
+        <rdar://problem/51556188>
+
+        Reviewed by Antti Koivisto.
+
+        Use the layout box's vertical alignment to adjust line baseline and height and set the run's logical top when the line is being closed.
+
+        * layout/inlineformatting/InlineLine.cpp:
+        (WebCore::Layout::Line::isVisuallyEmpty const):
+        (WebCore::Layout::Line::close):
+        (WebCore::Layout::Line::appendInlineContainerStart):
+        (WebCore::Layout::Line::appendTextContent):
+        (WebCore::Layout::Line::appendNonReplacedInlineBox):
+        (WebCore::Layout::Line::appendHardLineBreak):
+        (WebCore::Layout::Line::adjustBaselineAndLineHeight):
+        (WebCore::Layout::Line::inlineItemHeight const):
+        (WebCore::Layout::Line::Content::isVisuallyEmpty const): Deleted.
+        * layout/inlineformatting/InlineLine.h:
+        (WebCore::Layout::Line::Content::isVisuallyEmpty const):
+        (WebCore::Layout::Line::Content::setIsVisuallyEmpty):
+        (WebCore::Layout::Line::hasContent const):
+
 2019-06-14  Antoine Quint  <graouts@apple.com>
 

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

@@ -36 +36 @@
 WTF_MAKE_ISO_ALLOCATED_IMPL(Line);
 
-bool Line::Content::isVisuallyEmpty() const
-{
-    // Return true for empty inline containers like <span></span>.
-    for (auto& run : m_runs) {
-        if (run->inlineItem.isContainerStart() || run->inlineItem.isContainerEnd())
-            continue;
-        if (!run->isCollapsed)
-            return false;
-    }
-    return true;
-}
-
 Line::Content::Run::Run(const InlineItem& inlineItem, const Display::Rect& logicalRect, TextContext textContext, bool isCollapsed, bool canBeExtended)
     : inlineItem(inlineItem)
@@ -76 +64 @@
 }
 
+bool Line::isVisuallyEmpty() const
+{
+    // FIXME: This should be cached instead -as the inline items are being added.
+    // Return true for empty inline containers like <span></span>.
+    for (auto& run : m_content->runs()) {
+        if (run->inlineItem.isContainerStart()) {
+            auto& displayBox = m_layoutState.displayBoxForLayoutBox(run->inlineItem.layoutBox());
+            if (displayBox.horizontalBorder() || (displayBox.horizontalPadding() && displayBox.horizontalPadding().value()))
+                return false;
+            continue;
+        }
+        if (run->inlineItem.isContainerEnd())
+            continue;
+        if (!run->isCollapsed)
+            return false;
+    }
+    return true;
+}
+
 std::unique_ptr<Line::Content> Line::close()
 {
     removeTrailingTrimmableContent();
     if (!m_skipVerticalAligment) {
-        // Convert inline run geometry from relative to the baseline to relative to logical top.
         for (auto& run : m_content->runs()) {
-            auto adjustedLogicalTop = run->logicalRect.top() + baselineOffset();
-            run->logicalRect.setTop(adjustedLogicalTop);
-        }
-    }
+            LayoutUnit logicalTop;
+            auto& inlineItem = run->inlineItem;
+            auto& layoutBox = inlineItem.layoutBox();
+            auto ascent = inlineItem.style().fontMetrics().ascent();
+
+            switch (inlineItem.style().verticalAlign()) {
+            case VerticalAlign::Baseline:
+                if (inlineItem.isLineBreak() || inlineItem.isText())
+                    logicalTop = baselineOffset() - ascent;
+                else if (inlineItem.isContainerStart()) {
+                    auto& displayBox = m_layoutState.displayBoxForLayoutBox(layoutBox);
+                    logicalTop = baselineOffset() - ascent - displayBox.borderTop() - displayBox.paddingTop().valueOr(0);
+                } else if (layoutBox.isInlineBlockBox() && layoutBox.establishesInlineFormattingContext()) {
+                    auto& formattingState = downcast<InlineFormattingState>(m_layoutState.establishedFormattingState(layoutBox));
+                    // Spec makes us generate at least one line -even if it is empty.
+                    ASSERT(!formattingState.lineBoxes().isEmpty());
+                    auto inlineBlockBaseline = formattingState.lineBoxes().last().baseline();
+                    logicalTop = baselineOffset() - inlineBlockBaseline.ascent;
+                } else
+                    logicalTop = baselineOffset() - run->logicalRect.height();
+                break;
+            case VerticalAlign::Top:
+                logicalTop = { };
+                break;
+            case VerticalAlign::Bottom:
+                logicalTop = logicalBottom() - run->logicalRect.height();
+                break;
+            default:
+                ASSERT_NOT_IMPLEMENTED_YET();
+                break;
+            }
+            run->logicalRect.setTop(logicalTop);
+        }
+    }
+    m_content->setIsVisuallyEmpty(isVisuallyEmpty());
     m_content->setLogicalRect({ logicalTop(), logicalLeft(), contentLogicalWidth(), logicalHeight() });
     m_content->setBaseline(m_baseline);
@@ -143 +180 @@
         auto logicalHeight = inlineItemHeight(inlineItem);
         adjustBaselineAndLineHeight(inlineItem, logicalHeight);
-
-        auto& displayBox = m_layoutState.displayBoxForLayoutBox(inlineItem.layoutBox());
-        auto logicalTop = -inlineItem.style().fontMetrics().ascent() - displayBox.borderTop() - displayBox.paddingTop().valueOr(0);
-        logicalRect.setTop(logicalTop);
         logicalRect.setHeight(logicalHeight);
     }
@@ -191 +224 @@
     logicalRect.setLeft(contentLogicalRight());
     logicalRect.setWidth(logicalWidth);
-    if (!m_skipVerticalAligment) {
-        logicalRect.setTop(-inlineItem.style().fontMetrics().ascent());
+    if (!m_skipVerticalAligment)
         logicalRect.setHeight(inlineItemHeight(inlineItem));
-    }
 
     auto textContext = Content::Run::TextContext { inlineItem.start(), inlineItem.isCollapsed() ? 1 : inlineItem.length() };
@@ -216 +247 @@
         auto logicalHeight = inlineItemHeight(inlineItem);
         adjustBaselineAndLineHeight(inlineItem, logicalHeight);
-
-        logicalRect.setTop(-logicalHeight);
         logicalRect.setHeight(logicalHeight);
     }
@@ -234 +263 @@
 void Line::appendHardLineBreak(const InlineItem& inlineItem)
 {
-    auto ascent = inlineItem.layoutBox().style().fontMetrics().ascent();
-    auto logicalRect = Display::Rect { -ascent, contentLogicalRight(), { }, logicalHeight() };
+    auto logicalRect = Display::Rect { };
+    logicalRect.setLeft(contentLogicalRight());
+    logicalRect.setWidth({ });
+    if (!m_skipVerticalAligment)
+        logicalRect.setHeight(logicalHeight());
     m_content->runs().append(std::make_unique<Content::Run>(inlineItem, logicalRect, Content::Run::TextContext { }, false, false));
 }
@@ -256 +288 @@
     }
     // Replaced and non-replaced inline level box.
-    // FIXME: We need to look inside the inline-block's formatting context and check the lineboxes (if any) to be able to baseline align.
-    if (layoutBox.establishesInlineFormattingContext()) {
-        if (runHeight == logicalHeight())
-            return;
-        // FIXME: This fails when the line height difference comes from font-size diff.
+    switch (inlineItem.style().verticalAlign()) {
+    case VerticalAlign::Baseline:
+        if (layoutBox.isInlineBlockBox() && layoutBox.establishesInlineFormattingContext()) {
+            // Inline-blocks with inline content always have baselines.
+            auto& formattingState = downcast<InlineFormattingState>(m_layoutState.establishedFormattingState(layoutBox));
+            // Spec makes us generate at least one line -even if it is empty.
+            ASSERT(!formattingState.lineBoxes().isEmpty());
+            auto inlineBlockBaseline = formattingState.lineBoxes().last().baseline();
+            m_baseline.descent = std::max(inlineBlockBaseline.descent, m_baseline.descent);
+            m_baseline.ascent = std::max(inlineBlockBaseline.ascent, m_baseline.ascent);
+            m_contentLogicalHeight = std::max(std::max(m_contentLogicalHeight, runHeight), baselineAlignedContentHeight());
+            break;
+        }
         m_baseline.descent = std::max<LayoutUnit>(0, m_baseline.descent);
         m_baseline.ascent = std::max(runHeight, m_baseline.ascent);
         m_contentLogicalHeight = std::max(m_contentLogicalHeight, baselineAlignedContentHeight());
-        return;
-    }
-    // 0 descent -> baseline aligment for now.
-    m_baseline.descent = std::max<LayoutUnit>(0, m_baseline.descent);
-    m_baseline.ascent = std::max(runHeight, m_baseline.ascent);
-    m_contentLogicalHeight = std::max(m_contentLogicalHeight, baselineAlignedContentHeight());
+        break;
+    case VerticalAlign::Top:
+        // Top align content never changes the baseline offset, it only pushes the bottom of the line further down.
+        m_contentLogicalHeight = std::max(runHeight, m_contentLogicalHeight);
+        break;
+    case VerticalAlign::Bottom:
+        if (m_contentLogicalHeight < runHeight) {
+            m_baseline.offset = m_baseline.offset + (runHeight - m_contentLogicalHeight);
+            m_contentLogicalHeight = runHeight;
+        }
+        break;
+    default:
+        ASSERT_NOT_IMPLEMENTED_YET();
+        break;
+    }
 }
 
@@ -293 +342 @@
 
     // Non-replaced inline box (e.g. inline-block)
-    return displayBox.height();
+    return displayBox.marginBox().height();
 }
 

trunk/Source/WebCore/layout/inlineformatting/InlineLine.h

@@ -52 +52 @@
 
             const InlineItem& inlineItem;
-            // Relative to the baseline.
             Display::Rect logicalRect;
+            LayoutUnit baseline;
             Optional<TextContext> textContext;
             bool isCollapsed { false };
@@ -62 +62 @@
         bool isEmpty() const { return m_runs.isEmpty(); }
         // Not in painting sense though.
-        bool isVisuallyEmpty() const;
+        bool isVisuallyEmpty() const { return m_isVisuallyEmpty; }
 
         LayoutUnit logicalTop() const { return m_logicalRect.top(); }
@@ -77 +77 @@
         void setLogicalRect(const Display::Rect& logicalRect) { m_logicalRect = logicalRect; }
         void setBaseline(LineBox::Baseline baseline) { m_baseline = baseline; }
+        void setIsVisuallyEmpty(bool isVisuallyEmpty) { m_isVisuallyEmpty = isVisuallyEmpty; }
         Runs& runs() { return m_runs; }
 
@@ -82 +83 @@
         LineBox::Baseline m_baseline;
         Runs m_runs;
+        bool m_isVisuallyEmpty { true };
     };
     std::unique_ptr<Content> close();
@@ -92 +94 @@
     void appendHardLineBreak(const InlineItem&);
 
-    bool hasContent() const { return !m_content->isVisuallyEmpty(); }
+    bool hasContent() const { return !isVisuallyEmpty(); }
 
     LayoutUnit trailingTrimmableWidth() const;
@@ -122 +124 @@
     void adjustBaselineAndLineHeight(const InlineItem&, LayoutUnit runHeight);
     LayoutUnit inlineItemHeight(const InlineItem&) const;
+    bool isVisuallyEmpty() const;
 
     const LayoutState& m_layoutState;