[LFC][IFC] Add generic inline content handling.
[WebKit-https.git] / Source / WebCore / layout / inlineformatting / InlineFormattingContext.cpp
1 /*
2  * Copyright (C) 2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "InlineFormattingContext.h"
28
29 #if ENABLE(LAYOUT_FORMATTING_CONTEXT)
30
31 #include "FloatingState.h"
32 #include "InlineFormattingState.h"
33 #include "InlineLineBreaker.h"
34 #include "InlineRunProvider.h"
35 #include "LayoutBox.h"
36 #include "LayoutContainer.h"
37 #include "LayoutContext.h"
38 #include "LayoutInlineBox.h"
39 #include "LayoutInlineContainer.h"
40 #include "Logging.h"
41 #include <wtf/IsoMallocInlines.h>
42 #include <wtf/text/TextStream.h>
43
44 namespace WebCore {
45 namespace Layout {
46
47 WTF_MAKE_ISO_ALLOCATED_IMPL(InlineFormattingContext);
48
49 InlineFormattingContext::InlineFormattingContext(const Box& formattingContextRoot)
50     : FormattingContext(formattingContextRoot)
51 {
52 }
53
54 void InlineFormattingContext::layout(LayoutContext& layoutContext, FormattingState& formattingState) const
55 {
56     if (!is<Container>(root()))
57         return;
58
59     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> inline formatting context -> layout context(" << &layoutContext << ") formatting root(" << &root() << ")");
60
61     auto& inlineFormattingState = downcast<InlineFormattingState>(formattingState);
62     InlineRunProvider inlineRunProvider(inlineFormattingState);
63     auto& formattingRoot = downcast<Container>(root());
64     auto* layoutBox = formattingRoot.firstInFlowOrFloatingChild();
65     // Casually walk through the block's descendants and place the inline boxes one after the other as much as we can (yeah, I am looking at you floats).
66     while (layoutBox) {
67         if (is<Container>(layoutBox)) {
68             ASSERT(is<InlineContainer>(layoutBox));
69             layoutBox = downcast<Container>(*layoutBox).firstInFlowOrFloatingChild();
70             continue;
71         }
72
73         inlineRunProvider.append(*layoutBox);
74         computeWidthAndHeight(layoutContext, *layoutBox);
75
76         for (; layoutBox; layoutBox = layoutBox->parent()) {
77             if (layoutBox == &formattingRoot) {
78                 layoutBox = nullptr;
79                 break;
80             }
81             if (auto* nextSibling = layoutBox->nextInFlowOrFloatingSibling()) {
82                 layoutBox = nextSibling;
83                 break;
84             }
85         }
86         ASSERT(!layoutBox || layoutBox->isDescendantOf(formattingRoot));
87     }
88
89     layoutInlineContent(layoutContext, inlineFormattingState, inlineRunProvider);
90
91     LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> layout context(" << &layoutContext << ") formatting root(" << &root() << ")");
92 }
93
94 static bool trimLeadingRun(const InlineLineBreaker::Run& run)
95 {
96     ASSERT(run.position == InlineLineBreaker::Run::Position::LineBegin);
97
98     auto& inlineRun = run.inlineRun;
99     if (!inlineRun.isWhitespace())
100         return false;
101
102     return inlineRun.style().collapseWhiteSpace();
103 }
104
105 void InlineFormattingContext::layoutInlineContent(const LayoutContext& layoutContext, InlineFormattingState& inlineFormattingState, const InlineRunProvider& inlineRunProvider) const
106 {
107     auto& formattingRoot = downcast<Container>(root());
108     auto& formattingRootDisplayBox = layoutContext.displayBoxForLayoutBox(formattingRoot);
109
110     auto lineLogicalLeft = formattingRootDisplayBox.contentBoxLeft();
111     auto availableWidth = formattingRootDisplayBox.contentBoxWidth();
112     auto previousRunPositionIsLineEnd = false;
113
114     Line line(inlineFormattingState);
115     line.setConstraints(lineLogicalLeft, availableWidth);
116
117     InlineLineBreaker lineBreaker(layoutContext, inlineFormattingState.inlineContent(), inlineRunProvider.runs());
118     while (auto run = lineBreaker.nextRun(line.contentLogicalLeft(), line.availableWidth(), !line.hasContent())) {
119
120         if (run->position == InlineLineBreaker::Run::Position::LineBegin) {
121             // First run on line.
122
123             // Previous run ended up being at the line end. Adjust the line accordingly.
124             if (!previousRunPositionIsLineEnd) {
125                 line.close();
126                 line.setConstraints(lineLogicalLeft, availableWidth);
127             }
128             // Skip leading whitespace.
129             if (!trimLeadingRun(*run))
130                 line.appendContent(*run);
131             continue;
132         }
133
134         if (run->position == InlineLineBreaker::Run::Position::LineEnd) {
135             // Last run on line.
136             previousRunPositionIsLineEnd = true;
137             line.appendContent(*run);
138             // Move over to the next line.
139             line.close();
140             line.setConstraints(lineLogicalLeft, availableWidth);
141             continue;
142         }
143
144         // This may or may not be the last run on line -but definitely not the first one.
145         line.appendContent(*run);
146     }
147     line.close();
148 }
149
150 void InlineFormattingContext::computeWidthAndHeight(const LayoutContext& layoutContext, const Box& layoutBox) const
151 {
152     if (is<InlineBox>(layoutBox) && downcast<InlineBox>(layoutBox).hasTextContent()) {
153         // Text content width is computed during text run generation. -It does not make any sense to measure unprocessed text here, since it will likely be
154         // split up (or concatenated).
155         return;
156     }
157
158     if (layoutBox.isFloatingPositioned()) {
159         ASSERT_NOT_IMPLEMENTED_YET();
160         return;
161     }
162
163     if (layoutBox.isInlineBlockBox()) {
164         ASSERT_NOT_IMPLEMENTED_YET();
165         return;
166     }
167
168     if (layoutBox.replaced()) {
169         computeBorderAndPadding(layoutContext, layoutBox);
170
171         auto& displayBox = layoutContext.displayBoxForLayoutBox(layoutBox);
172
173         auto widthAndMargin = Geometry::inlineReplacedWidthAndMargin(layoutContext, layoutBox);
174         displayBox.setContentBoxWidth(widthAndMargin.width);
175         displayBox.setHorizontalMargin(widthAndMargin.margin);
176         displayBox.setHorizontalNonComputedMargin(widthAndMargin.nonComputedMargin);
177
178         auto heightAndMargin = Geometry::inlineReplacedHeightAndMargin(layoutContext, layoutBox);
179         displayBox.setContentBoxHeight(heightAndMargin.height);
180         displayBox.setVerticalNonCollapsedMargin(heightAndMargin.margin);
181         displayBox.setVerticalMargin(heightAndMargin.collapsedMargin.value_or(heightAndMargin.margin));
182         return;
183     }
184
185     ASSERT_NOT_REACHED();
186     return;
187 }
188
189 void InlineFormattingContext::computeStaticPosition(const LayoutContext&, const Box&) const
190 {
191 }
192
193 void InlineFormattingContext::computeInFlowPositionedPosition(const LayoutContext&, const Box&) const
194 {
195 }
196
197 FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsicWidthConstraints(LayoutContext&, const Box&) const
198 {
199     return { };
200 }
201
202 }
203 }
204
205 #endif