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(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.isInlineBlockBox()) {
 171         ASSERT_NOT_IMPLEMENTED_YET();
 172         return;
 173     }
 174
 175     computeBorderAndPadding(layoutContext, layoutBox);
 176
 177     WidthAndMargin widthAndMargin;
 178     HeightAndMargin heightAndMargin;
 179
 180     if (layoutBox.isFloatingPositioned()) {
 181         widthAndMargin = Geometry::floatingWidthAndMargin(layoutContext, *this, layoutBox);
 182         heightAndMargin = Geometry::floatingHeightAndMargin(layoutContext, layoutBox);
 183     } else if (layoutBox.replaced()) {
 184         widthAndMargin = Geometry::inlineReplacedWidthAndMargin(layoutContext, layoutBox);
 185         heightAndMargin = Geometry::inlineReplacedHeightAndMargin(layoutContext, layoutBox);
 186     } else
 187         ASSERT_NOT_REACHED();
 188
 189     auto& displayBox = layoutContext.displayBoxForLayoutBox(layoutBox);
 190     displayBox.setContentBoxWidth(widthAndMargin.width);
 191     displayBox.setHorizontalMargin(widthAndMargin.margin);
 192     displayBox.setHorizontalNonComputedMargin(widthAndMargin.nonComputedMargin);
 193
 194     displayBox.setContentBoxHeight(heightAndMargin.height);
 195     displayBox.setVerticalNonCollapsedMargin(heightAndMargin.margin);
 196     displayBox.setVerticalMargin(heightAndMargin.collapsedMargin.value_or(heightAndMargin.margin));
 197     return;
 198 }
 199
 200 void InlineFormattingContext::computeFloatPosition(const LayoutContext& layoutContext, const FloatingContext& floatingContext, Line& line, const Box& floatBox) const
 201 {
 202     ASSERT(layoutContext.hasDisplayBox(floatBox));
 203     auto& displayBox = layoutContext.displayBoxForLayoutBox(floatBox);
 204
 205     // Set static position first.
 206     displayBox.setTopLeft({ line.contentLogicalRight(), line.logicalTop() });
 207     // Float it.
 208     displayBox.setTopLeft(floatingContext.positionForFloat(floatBox));
 209 }
 210
 211 void InlineFormattingContext::computeStaticPosition(const LayoutContext&, const Box&) const
 212 {
 213 }
 214
 215 void InlineFormattingContext::computeInFlowPositionedPosition(const LayoutContext&, const Box&) const
 216 {
 217 }
 218
 219 FormattingContext::InstrinsicWidthConstraints InlineFormattingContext::instrinsicWidthConstraints(LayoutContext&, const Box&) const
 220 {
 221     return { };
 222 }
 223
 224 }
 225 }
 226
 227 #endif