| /* |
| * Copyright (C) 2018 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "InlineFormattingGeometry.h" |
| |
| #if ENABLE(LAYOUT_FORMATTING_CONTEXT) |
| |
| #include "FloatingContext.h" |
| #include "FontCascade.h" |
| #include "FormattingContext.h" |
| #include "InlineFormattingContext.h" |
| #include "InlineFormattingQuirks.h" |
| #include "InlineLineBoxVerticalAligner.h" |
| #include "LayoutBox.h" |
| #include "LayoutContainerBox.h" |
| #include "LayoutReplacedBox.h" |
| #include "LengthFunctions.h" |
| |
| namespace WebCore { |
| namespace Layout { |
| |
| InlineFormattingGeometry::InlineFormattingGeometry(const InlineFormattingContext& inlineFormattingContext) |
| : FormattingGeometry(inlineFormattingContext) |
| { |
| } |
| |
| InlineLayoutUnit InlineFormattingGeometry::logicalTopForNextLine(const LineBuilder::LineContent& lineContent, InlineLayoutUnit previousLineLogicalBottom, const FloatingContext& floatingContext) const |
| { |
| // Normally the next line's logical top is the previous line's logical bottom, but when the line ends |
| // with the clear property set, the next line needs to clear the existing floats. |
| if (lineContent.runs.isEmpty()) |
| return previousLineLogicalBottom; |
| auto& lastRunLayoutBox = lineContent.runs.last().layoutBox(); |
| if (lastRunLayoutBox.style().clear() == Clear::None) |
| return previousLineLogicalBottom; |
| auto positionWithClearance = floatingContext.verticalPositionWithClearance(lastRunLayoutBox); |
| if (!positionWithClearance) |
| return previousLineLogicalBottom; |
| return std::max(previousLineLogicalBottom, InlineLayoutUnit(positionWithClearance->position)); |
| } |
| |
| ContentWidthAndMargin InlineFormattingGeometry::inlineBlockContentWidthAndMargin(const Box& formattingContextRoot, const HorizontalConstraints& horizontalConstraints, const OverriddenHorizontalValues& overriddenHorizontalValues) const |
| { |
| ASSERT(formattingContextRoot.isInFlow()); |
| |
| // 10.3.10 'Inline-block', replaced elements in normal flow |
| |
| // Exactly as inline replaced elements. |
| if (formattingContextRoot.isReplacedBox()) |
| return inlineReplacedContentWidthAndMargin(downcast<ReplacedBox>(formattingContextRoot), horizontalConstraints, { }, overriddenHorizontalValues); |
| |
| // 10.3.9 'Inline-block', non-replaced elements in normal flow |
| |
| // If 'width' is 'auto', the used value is the shrink-to-fit width as for floating elements. |
| // A computed value of 'auto' for 'margin-left' or 'margin-right' becomes a used value of '0'. |
| // #1 |
| auto width = computedValue(formattingContextRoot.style().logicalWidth(), horizontalConstraints.logicalWidth); |
| if (!width) |
| width = shrinkToFitWidth(formattingContextRoot, horizontalConstraints.logicalWidth); |
| |
| // #2 |
| auto computedHorizontalMargin = FormattingGeometry::computedHorizontalMargin(formattingContextRoot, horizontalConstraints); |
| |
| return ContentWidthAndMargin { *width, { computedHorizontalMargin.start.value_or(0_lu), computedHorizontalMargin.end.value_or(0_lu) } }; |
| } |
| |
| ContentHeightAndMargin InlineFormattingGeometry::inlineBlockContentHeightAndMargin(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const OverriddenVerticalValues& overriddenVerticalValues) const |
| { |
| ASSERT(layoutBox.isInFlow()); |
| |
| // 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, 'inline-block' replaced elements in normal flow and floating replaced elements |
| if (layoutBox.isReplacedBox()) |
| return inlineReplacedContentHeightAndMargin(downcast<ReplacedBox>(layoutBox), horizontalConstraints, { }, overriddenVerticalValues); |
| |
| // 10.6.6 Complicated cases |
| // - 'Inline-block', non-replaced elements. |
| return complicatedCases(layoutBox, horizontalConstraints, overriddenVerticalValues); |
| } |
| |
| bool InlineFormattingGeometry::inlineLevelBoxAffectsLineBox(const InlineLevelBox& inlineLevelBox, const LineBox& lineBox) const |
| { |
| if (inlineLevelBox.isInlineBox() || inlineLevelBox.isLineBreakBox()) |
| return layoutState().inStandardsMode() ? true : formattingContext().formattingQuirks().inlineLevelBoxAffectsLineBox(inlineLevelBox, lineBox); |
| if (inlineLevelBox.isListMarker()) |
| return inlineLevelBox.layoutBounds().height(); |
| if (inlineLevelBox.isAtomicInlineLevelBox()) { |
| if (inlineLevelBox.layoutBounds().height()) |
| return true; |
| // While in practice when the negative vertical margin makes the layout bounds empty (e.g: height: 100px; margin-top: -100px;), and this inline |
| // level box contributes 0px to the line box height, it still needs to be taken into account while computing line box geometries. |
| auto& boxGeometry = formattingContext().geometryForBox(inlineLevelBox.layoutBox()); |
| return boxGeometry.marginBefore() || boxGeometry.marginAfter(); |
| } |
| return false; |
| } |
| |
| InlineRect InlineFormattingGeometry::flipVisualRectToLogicalForWritingMode(const InlineRect& visualRect, WritingMode writingMode) |
| { |
| switch (writingMode) { |
| case WritingMode::TopToBottom: |
| return visualRect; |
| case WritingMode::LeftToRight: |
| case WritingMode::RightToLeft: { |
| // FIXME: While vertical-lr and vertical-rl modes do differ in the ordering direction of line boxes |
| // in a block container (see: https://drafts.csswg.org/css-writing-modes/#block-flow) |
| // we ignore it for now as RenderBlock takes care of it for us. |
| return InlineRect { visualRect.left(), visualRect.top(), visualRect.height(), visualRect.width() }; |
| } |
| default: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| return visualRect; |
| } |
| |
| } |
| } |
| |
| #endif |