6f1ab7294f0de2336cc38e53fbdaf8856fa1b9c7
[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     if (!run.content.isWhitespace())
99         return false;
100
101     return run.content.style().collapseWhiteSpace();
102 }
103
104 void InlineFormattingContext::initializeNewLine(const LayoutContext& layoutContext, Line& line) const
105 {
106     auto& formattingRoot = downcast<Container>(root());
107     auto& formattingRootDisplayBox = layoutContext.displayBoxForLayoutBox(formattingRoot);
108
109     auto lineLogicalLeft = formattingRootDisplayBox.contentBoxLeft();
110     auto lineLogicalTop = line.isFirstLine() ? formattingRootDisplayBox.contentBoxTop() : line.logicalBottom();
111     auto availableWidth = formattingRootDisplayBox.contentBoxWidth();
112
113     Display::Box::Rect logicalRect;
114     logicalRect.setTop(lineLogicalTop);
115     logicalRect.setLeft(lineLogicalLeft);
116     logicalRect.setWidth(availableWidth);
117     logicalRect.setHeight(formattingRoot.style().computedLineHeight());
118
119     line.init(logicalRect);
120 }
121
122 void InlineFormattingContext::layoutInlineContent(const LayoutContext& layoutContext, InlineFormattingState& inlineFormattingState, const InlineRunProvider& inlineRunProvider) const
123 {
124     auto previousRunPositionIsLineEnd = false;
125
126     Line line(inlineFormattingState, root());
127     initializeNewLine(layoutContext, line);
128
129     InlineLineBreaker lineBreaker(layoutContext, inlineFormattingState.inlineContent(), inlineRunProvider.runs());
130     while (auto run = lineBreaker.nextRun(line.contentLogicalRight(), line.availableWidth(), !line.hasContent())) {
131
132         if (run->position == InlineLineBreaker::Run::Position::LineBegin) {
133             // First run on line.
134
135             // Previous run ended up being at the line end. Adjust the line accordingly.
136             if (!previousRunPositionIsLineEnd) {
137                 line.close();
138                 initializeNewLine(layoutContext, line);
139             }
140             // Skip leading whitespace.
141             if (!trimLeadingRun(*run))
142                 line.appendContent(*run);
143             continue;
144         }
145
146         if (run->position == InlineLineBreaker::Run::Position::LineEnd) {
147             // Last run on line.
148             previousRunPositionIsLineEnd = true;
149             line.appendContent(*run);
150             // Move over to the next line.
151             line.close();
152             initializeNewLine(layoutContext, line);
153             continue;
154         }
155
156         // This may or may not be the last run on line -but definitely not the first one.
157         line.appendContent(*run);
158     }
159     line.close(Line::LastLine::Yes);
160 }
161
162 void InlineFormattingContext::computeWidthAndHeight(const LayoutContext& layoutContext, const Box& layoutBox) const
163 {
164     if (is<InlineBox>(layoutBox) && downcast<InlineBox>(layoutBox).hasTextContent()) {
165         // 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
166         // split up (or concatenated).
167         return;
168     }
169
170     if (layoutBox.isFloatingPositioned()) {
171         ASSERT_NOT_IMPLEMENTED_YET();
172         return;
173     }
174
175     if (layoutBox.isInlineBlockBox()) {
176         ASSERT_NOT_IMPLEMENTED_YET();
177         return;
178     }
179
180     if (layoutBox.replaced()) {
181         computeBorderAndPadding(layoutContext, layoutBox);
182
183         auto& displayBox = layoutContext.displayBoxForLayoutBox(layoutBox);
184
185         auto widthAndMargin = Geometry::inlineReplacedWidthAndMargin(layoutContext, layoutBox);
186         displayBox.setContentBoxWidth(widthAndMargin.width);
187         displayBox.setHorizontalMargin(widthAndMargin.margin);
188         displayBox.setHorizontalNonComputedMargin(widthAndMargin.nonComputedMargin);
189
190         auto heightAndMargin = Geometry::inlineReplacedHeightAndMargin(layoutContext, layoutBox);
191         displayBox.setContentBoxHeight(heightAndMargin.height);
192         displayBox.setVerticalNonCollapsedMargin(heightAndMargin.margin);
193         displayBox.setVerticalMargin(heightAndMargin.collapsedMargin.value_or(heightAndMargin.margin));
194         return;
195     }
196
197     ASSERT_NOT_REACHED();
198     return;
199 }
200
201 void InlineFormattingContext::computeStaticPosition(const LayoutContext&, const Box&) const
202 {
203 }
204
205 void InlineFormattingContext::computeInFlowPositionedPosition(const LayoutContext&, const Box&) const
206 {
207 }
208
209 FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsicWidthConstraints(LayoutContext&, const Box&) const
210 {
211     return { };
212 }
213
214 }
215 }
216
217 #endif