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