| /* |
| * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
| * (C) 1999 Antti Koivisto (koivisto@kde.org) |
| * Copyright (C) 2003, 2006, 2007 Apple Inc. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| * |
| */ |
| |
| #ifndef LayoutBox_h |
| #define LayoutBox_h |
| |
| #include "core/CoreExport.h" |
| #include "core/layout/LayoutBoxModelObject.h" |
| #include "core/layout/OverflowModel.h" |
| #include "core/layout/ScrollEnums.h" |
| #include "platform/scroll/ScrollTypes.h" |
| #include "wtf/PtrUtil.h" |
| #include <memory> |
| |
| namespace blink { |
| |
| class LayoutBlockFlow; |
| class LayoutMultiColumnSpannerPlaceholder; |
| class ShapeOutsideInfo; |
| |
| struct PaintInfo; |
| |
| enum SizeType { MainOrPreferredSize, MinSize, MaxSize }; |
| enum AvailableLogicalHeightType { |
| ExcludeMarginBorderPadding, |
| IncludeMarginBorderPadding |
| }; |
| // When painting, overlay scrollbars do not take up space and should not affect |
| // clipping behavior. During hit testing, overlay scrollbars behave like regular |
| // scrollbars and should change how hit testing is clipped. |
| enum MarginDirection { BlockDirection, InlineDirection }; |
| enum BackgroundRectType { BackgroundClipRect, BackgroundKnownOpaqueRect }; |
| |
| enum ShouldComputePreferred { ComputeActual, ComputePreferred }; |
| |
| enum ApplyOverflowClipFlag { |
| ApplyOverflowClip, |
| // Don't apply overflow clipping or scrolling. |
| ApplyNonScrollOverflowClip |
| }; |
| |
| using SnapAreaSet = HashSet<const LayoutBox*>; |
| |
| struct LayoutBoxRareData { |
| WTF_MAKE_NONCOPYABLE(LayoutBoxRareData); |
| USING_FAST_MALLOC(LayoutBoxRareData); |
| |
| public: |
| LayoutBoxRareData() |
| : m_spannerPlaceholder(nullptr), |
| m_overrideLogicalContentWidth(-1), |
| m_overrideLogicalContentHeight(-1), |
| m_hasOverrideContainingBlockContentLogicalWidth(false), |
| m_hasOverrideContainingBlockContentLogicalHeight(false), |
| m_percentHeightContainer(nullptr), |
| m_snapContainer(nullptr), |
| m_snapAreas(nullptr) {} |
| |
| // For spanners, the spanner placeholder that lays us out within the multicol |
| // container. |
| LayoutMultiColumnSpannerPlaceholder* m_spannerPlaceholder; |
| |
| LayoutUnit m_overrideLogicalContentWidth; |
| LayoutUnit m_overrideLogicalContentHeight; |
| |
| bool m_hasOverrideContainingBlockContentLogicalWidth; |
| bool m_hasOverrideContainingBlockContentLogicalHeight; |
| LayoutUnit m_overrideContainingBlockContentLogicalWidth; |
| LayoutUnit m_overrideContainingBlockContentLogicalHeight; |
| |
| LayoutUnit m_pageLogicalOffset; |
| LayoutUnit m_paginationStrut; |
| |
| LayoutBlock* m_percentHeightContainer; |
| // For snap area, the owning snap container. |
| LayoutBox* m_snapContainer; |
| // For snap container, the descendant snap areas that contribute snap |
| // points. |
| std::unique_ptr<SnapAreaSet> m_snapAreas; |
| |
| SnapAreaSet& ensureSnapAreas() { |
| if (!m_snapAreas) |
| m_snapAreas = wrapUnique(new SnapAreaSet); |
| |
| return *m_snapAreas; |
| } |
| }; |
| |
| // LayoutBox implements the full CSS box model. |
| // |
| // LayoutBoxModelObject only introduces some abstractions for LayoutInline and |
| // LayoutBox. The logic for the model is in LayoutBox, e.g. the storage for the |
| // rectangle and offset forming the CSS box (m_frameRect) and the getters for |
| // the different boxes. |
| // |
| // LayoutBox is also the uppermost class to support scrollbars, however the |
| // logic is delegated to PaintLayerScrollableArea. |
| // Per the CSS specification, scrollbars should "be inserted between the inner |
| // border edge and the outer padding edge". |
| // (see http://www.w3.org/TR/CSS21/visufx.html#overflow) |
| // Also the scrollbar width / height are removed from the content box. Taking |
| // the following example: |
| // |
| // <!DOCTYPE html> |
| // <style> |
| // ::-webkit-scrollbar { |
| // /* Force non-overlay scrollbars */ |
| // width: 10px; |
| // height: 20px; |
| // } |
| // </style> |
| // <div style="overflow:scroll; width: 100px; height: 100px"> |
| // |
| // The <div>'s content box is not 100x100 as specified in the style but 90x80 as |
| // we remove the scrollbars from the box. |
| // |
| // The presence of scrollbars is determined by the 'overflow' property and can |
| // be conditioned on having layout overflow (see OverflowModel for more details |
| // on how we track overflow). |
| // |
| // There are 2 types of scrollbars: |
| // - non-overlay scrollbars take space from the content box. |
| // - overlay scrollbars don't and just overlay hang off from the border box, |
| // potentially overlapping with the padding box's content. |
| // For more details on scrollbars, see PaintLayerScrollableArea. |
| // |
| // |
| // ***** THE BOX MODEL ***** |
| // The CSS box model is based on a series of nested boxes: |
| // http://www.w3.org/TR/CSS21/box.html |
| // |
| // |----------------------------------------------------| |
| // | | |
| // | margin-top | |
| // | | |
| // | |-----------------------------------------| | |
| // | | | | |
| // | | border-top | | |
| // | | | | |
| // | | |--------------------------|----| | | |
| // | | | | | | | |
| // | | | padding-top |####| | | |
| // | | | |####| | | |
| // | | | |----------------| |####| | | |
| // | | | | | | | | | |
| // | ML | BL | PL | content box | PR | SW | BR | MR | |
| // | | | | | | | | | |
| // | | | |----------------| | | | | |
| // | | | | | | | |
| // | | | padding-bottom | | | | |
| // | | |--------------------------|----| | | |
| // | | | ####| | | | |
| // | | | scrollbar height ####| SC | | | |
| // | | | ####| | | | |
| // | | |-------------------------------| | | |
| // | | | | |
| // | | border-bottom | | |
| // | | | | |
| // | |-----------------------------------------| | |
| // | | |
| // | margin-bottom | |
| // | | |
| // |----------------------------------------------------| |
| // |
| // BL = border-left |
| // BR = border-right |
| // ML = margin-left |
| // MR = margin-right |
| // PL = padding-left |
| // PR = padding-right |
| // SC = scroll corner (contains UI for resizing (see the 'resize' property) |
| // SW = scrollbar width |
| // |
| // Those are just the boxes from the CSS model. Extra boxes are tracked by Blink |
| // (e.g. the overflows). Thus it is paramount to know which box a function is |
| // manipulating. Also of critical importance is the coordinate system used (see |
| // the COORDINATE SYSTEMS section in LayoutBoxModelObject). |
| class CORE_EXPORT LayoutBox : public LayoutBoxModelObject { |
| public: |
| explicit LayoutBox(ContainerNode*); |
| |
| PaintLayerType layerTypeRequired() const override; |
| |
| bool backgroundIsKnownToBeOpaqueInRect( |
| const LayoutRect& localRect) const override; |
| |
| virtual bool backgroundShouldAlwaysBeClipped() const { return false; } |
| |
| // Use this with caution! No type checking is done! |
| LayoutBox* firstChildBox() const; |
| LayoutBox* lastChildBox() const; |
| |
| int pixelSnappedWidth() const { return m_frameRect.pixelSnappedWidth(); } |
| int pixelSnappedHeight() const { return m_frameRect.pixelSnappedHeight(); } |
| |
| void setX(LayoutUnit x) { |
| if (x == m_frameRect.x()) |
| return; |
| m_frameRect.setX(x); |
| frameRectChanged(); |
| } |
| void setY(LayoutUnit y) { |
| if (y == m_frameRect.y()) |
| return; |
| m_frameRect.setY(y); |
| frameRectChanged(); |
| } |
| void setWidth(LayoutUnit width) { |
| if (width == m_frameRect.width()) |
| return; |
| m_frameRect.setWidth(width); |
| frameRectChanged(); |
| } |
| void setHeight(LayoutUnit height) { |
| if (height == m_frameRect.height()) |
| return; |
| m_frameRect.setHeight(height); |
| frameRectChanged(); |
| } |
| |
| LayoutUnit logicalLeft() const { |
| return style()->isHorizontalWritingMode() ? m_frameRect.x() |
| : m_frameRect.y(); |
| } |
| LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); } |
| LayoutUnit logicalTop() const { |
| return style()->isHorizontalWritingMode() ? m_frameRect.y() |
| : m_frameRect.x(); |
| } |
| LayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); } |
| LayoutUnit logicalWidth() const { |
| return style()->isHorizontalWritingMode() ? m_frameRect.width() |
| : m_frameRect.height(); |
| } |
| LayoutUnit logicalHeight() const { |
| return style()->isHorizontalWritingMode() ? m_frameRect.height() |
| : m_frameRect.width(); |
| } |
| |
| LayoutUnit constrainLogicalWidthByMinMax(LayoutUnit, |
| LayoutUnit, |
| LayoutBlock*) const; |
| LayoutUnit constrainLogicalHeightByMinMax( |
| LayoutUnit logicalHeight, |
| LayoutUnit intrinsicContentHeight) const; |
| LayoutUnit constrainContentBoxLogicalHeightByMinMax( |
| LayoutUnit logicalHeight, |
| LayoutUnit intrinsicContentHeight) const; |
| |
| int pixelSnappedLogicalHeight() const { |
| return style()->isHorizontalWritingMode() ? pixelSnappedHeight() |
| : pixelSnappedWidth(); |
| } |
| int pixelSnappedLogicalWidth() const { |
| return style()->isHorizontalWritingMode() ? pixelSnappedWidth() |
| : pixelSnappedHeight(); |
| } |
| |
| LayoutUnit minimumLogicalHeightForEmptyLine() const { |
| return borderAndPaddingLogicalHeight() + scrollbarLogicalHeight() + |
| lineHeight(true, |
| isHorizontalWritingMode() ? HorizontalLine : VerticalLine, |
| PositionOfInteriorLineBoxes); |
| } |
| |
| void setLogicalLeft(LayoutUnit left) { |
| if (style()->isHorizontalWritingMode()) |
| setX(left); |
| else |
| setY(left); |
| } |
| void setLogicalTop(LayoutUnit top) { |
| if (style()->isHorizontalWritingMode()) |
| setY(top); |
| else |
| setX(top); |
| } |
| void setLogicalLocation(const LayoutPoint& location) { |
| if (style()->isHorizontalWritingMode()) |
| setLocation(location); |
| else |
| setLocation(location.transposedPoint()); |
| } |
| void setLogicalWidth(LayoutUnit size) { |
| if (style()->isHorizontalWritingMode()) |
| setWidth(size); |
| else |
| setHeight(size); |
| } |
| void setLogicalHeight(LayoutUnit size) { |
| if (style()->isHorizontalWritingMode()) |
| setHeight(size); |
| else |
| setWidth(size); |
| } |
| |
| LayoutPoint location() const { return m_frameRect.location(); } |
| LayoutSize locationOffset() const { |
| return LayoutSize(m_frameRect.x(), m_frameRect.y()); |
| } |
| LayoutSize size() const { return m_frameRect.size(); } |
| IntSize pixelSnappedSize() const { return m_frameRect.pixelSnappedSize(); } |
| |
| void setLocation(const LayoutPoint& location) { |
| if (location == m_frameRect.location()) |
| return; |
| m_frameRect.setLocation(location); |
| frameRectChanged(); |
| } |
| |
| // The ancestor box that this object's location and topLeftLocation are |
| // relative to. |
| virtual LayoutBox* locationContainer() const; |
| |
| // FIXME: Currently scrollbars are using int geometry and positioned based on |
| // pixelSnappedBorderBoxRect whose size may change when location changes |
| // because of pixel snapping. This function is used to change location of the |
| // LayoutBox outside of LayoutBox::layout(). Will remove when we use |
| // LayoutUnits for scrollbars. |
| void setLocationAndUpdateOverflowControlsIfNeeded(const LayoutPoint&); |
| |
| void setSize(const LayoutSize& size) { |
| if (size == m_frameRect.size()) |
| return; |
| m_frameRect.setSize(size); |
| frameRectChanged(); |
| } |
| void move(LayoutUnit dx, LayoutUnit dy) { |
| if (!dx && !dy) |
| return; |
| m_frameRect.move(dx, dy); |
| frameRectChanged(); |
| } |
| |
| // This function is in the container's coordinate system, meaning |
| // that it includes the logical top/left offset and the |
| // inline-start/block-start margins. |
| LayoutRect frameRect() const { return m_frameRect; } |
| void setFrameRect(const LayoutRect& rect) { |
| if (rect == m_frameRect) |
| return; |
| m_frameRect = rect; |
| frameRectChanged(); |
| } |
| |
| // Note that those functions have their origin at this box's CSS border box. |
| // As such their location doesn't account for 'top'/'left'. |
| LayoutRect borderBoxRect() const { return LayoutRect(LayoutPoint(), size()); } |
| LayoutRect paddingBoxRect() const { |
| return LayoutRect(LayoutUnit(borderLeft()), LayoutUnit(borderTop()), |
| clientWidth(), clientHeight()); |
| } |
| IntRect pixelSnappedBorderBoxRect() const { |
| return IntRect(IntPoint(), m_frameRect.pixelSnappedSize()); |
| } |
| IntRect borderBoundingBox() const final { |
| return pixelSnappedBorderBoxRect(); |
| } |
| |
| // The content area of the box (excludes padding - and intrinsic padding for |
| // table cells, etc... - and border). |
| DISABLE_CFI_PERF LayoutRect contentBoxRect() const { |
| return LayoutRect(borderLeft() + paddingLeft(), borderTop() + paddingTop(), |
| contentWidth(), contentHeight()); |
| } |
| LayoutSize contentBoxOffset() const { |
| return LayoutSize(borderLeft() + paddingLeft(), borderTop() + paddingTop()); |
| } |
| // The content box in absolute coords. Ignores transforms. |
| IntRect absoluteContentBox() const; |
| // The offset of the content box in absolute coords, ignoring transforms. |
| IntSize absoluteContentBoxOffset() const; |
| // The content box converted to absolute coords (taking transforms into |
| // account). |
| FloatQuad absoluteContentQuad() const; |
| // The enclosing rectangle of the background with given opacity requirement. |
| LayoutRect backgroundRect(BackgroundRectType) const; |
| |
| // This returns the content area of the box (excluding padding and border). |
| // The only difference with contentBoxRect is that computedCSSContentBoxRect |
| // does include the intrinsic padding in the content box as this is what some |
| // callers expect (like getComputedStyle). |
| LayoutRect computedCSSContentBoxRect() const { |
| return LayoutRect( |
| borderLeft() + computedCSSPaddingLeft(), |
| borderTop() + computedCSSPaddingTop(), |
| clientWidth() - computedCSSPaddingLeft() - computedCSSPaddingRight(), |
| clientHeight() - computedCSSPaddingTop() - computedCSSPaddingBottom()); |
| } |
| |
| void addOutlineRects(Vector<LayoutRect>&, |
| const LayoutPoint& additionalOffset, |
| IncludeBlockVisualOverflowOrNot) const override; |
| |
| // Use this with caution! No type checking is done! |
| LayoutBox* previousSiblingBox() const; |
| LayoutBox* previousInFlowSiblingBox() const; |
| LayoutBox* nextSiblingBox() const; |
| LayoutBox* nextInFlowSiblingBox() const; |
| LayoutBox* parentBox() const; |
| |
| // Return the previous sibling column set or spanner placeholder. Only to be |
| // used on multicol container children. |
| LayoutBox* previousSiblingMultiColumnBox() const; |
| // Return the next sibling column set or spanner placeholder. Only to be used |
| // on multicol container children. |
| LayoutBox* nextSiblingMultiColumnBox() const; |
| |
| bool canResize() const; |
| |
| // Visual and layout overflow are in the coordinate space of the box. This |
| // means that they aren't purely physical directions. For horizontal-tb and |
| // vertical-lr they will match physical directions, but for vertical-rl, the |
| // left/right are flipped when compared to their physical counterparts. |
| // For example minX is on the left in vertical-lr, but it is on the right in |
| // vertical-rl. |
| LayoutRect noOverflowRect() const; |
| LayoutRect layoutOverflowRect() const { |
| return m_overflow ? m_overflow->layoutOverflowRect() : noOverflowRect(); |
| } |
| IntRect pixelSnappedLayoutOverflowRect() const { |
| return pixelSnappedIntRect(layoutOverflowRect()); |
| } |
| LayoutSize maxLayoutOverflow() const { |
| return LayoutSize(layoutOverflowRect().maxX(), layoutOverflowRect().maxY()); |
| } |
| LayoutUnit logicalLeftLayoutOverflow() const { |
| return style()->isHorizontalWritingMode() ? layoutOverflowRect().x() |
| : layoutOverflowRect().y(); |
| } |
| LayoutUnit logicalRightLayoutOverflow() const { |
| return style()->isHorizontalWritingMode() ? layoutOverflowRect().maxX() |
| : layoutOverflowRect().maxY(); |
| } |
| |
| LayoutRect visualOverflowRect() const override; |
| LayoutUnit logicalLeftVisualOverflow() const { |
| return style()->isHorizontalWritingMode() ? visualOverflowRect().x() |
| : visualOverflowRect().y(); |
| } |
| LayoutUnit logicalRightVisualOverflow() const { |
| return style()->isHorizontalWritingMode() ? visualOverflowRect().maxX() |
| : visualOverflowRect().maxY(); |
| } |
| |
| LayoutRect selfVisualOverflowRect() const { |
| return m_overflow ? m_overflow->selfVisualOverflowRect() : borderBoxRect(); |
| } |
| LayoutRect contentsVisualOverflowRect() const { |
| return m_overflow ? m_overflow->contentsVisualOverflowRect() : LayoutRect(); |
| } |
| |
| // These methods don't mean the box *actually* has top/left overflow. They |
| // mean that *if* the box overflows, it will overflow to the top/left rather |
| // than the bottom/right. This happens when child content is laid out |
| // right-to-left (e.g. direction:rtl) or or bottom-to-top (e.g. direction:rtl |
| // writing-mode:vertical-rl). |
| virtual bool hasTopOverflow() const; |
| virtual bool hasLeftOverflow() const; |
| |
| void addLayoutOverflow(const LayoutRect&); |
| void addSelfVisualOverflow(const LayoutRect&); |
| void addContentsVisualOverflow(const LayoutRect&); |
| |
| void addVisualEffectOverflow(); |
| LayoutRectOutsets computeVisualEffectOverflowOutsets() const; |
| void addOverflowFromChild(LayoutBox* child) { |
| addOverflowFromChild(child, child->locationOffset()); |
| } |
| void addOverflowFromChild(LayoutBox* child, const LayoutSize& delta); |
| void clearLayoutOverflow(); |
| void clearAllOverflows() { m_overflow.reset(); } |
| |
| void updateLayerTransformAfterLayout(); |
| |
| DISABLE_CFI_PERF LayoutUnit contentWidth() const { |
| return clientWidth() - paddingLeft() - paddingRight(); |
| } |
| DISABLE_CFI_PERF LayoutUnit contentHeight() const { |
| return clientHeight() - paddingTop() - paddingBottom(); |
| } |
| LayoutSize contentSize() const { |
| return LayoutSize(contentWidth(), contentHeight()); |
| } |
| LayoutUnit contentLogicalWidth() const { |
| return style()->isHorizontalWritingMode() ? contentWidth() |
| : contentHeight(); |
| } |
| LayoutUnit contentLogicalHeight() const { |
| return style()->isHorizontalWritingMode() ? contentHeight() |
| : contentWidth(); |
| } |
| |
| // IE extensions. Used to calculate offsetWidth/Height. Overridden by inlines |
| // (LayoutFlow) to return the remaining width on a given line (and the height |
| // of a single line). |
| LayoutUnit offsetWidth() const override { return m_frameRect.width(); } |
| LayoutUnit offsetHeight() const override { return m_frameRect.height(); } |
| |
| int pixelSnappedOffsetWidth(const Element*) const final; |
| int pixelSnappedOffsetHeight(const Element*) const final; |
| |
| // More IE extensions. clientWidth and clientHeight represent the interior of |
| // an object excluding border and scrollbar. clientLeft/Top are just the |
| // borderLeftWidth and borderTopWidth. |
| DISABLE_CFI_PERF LayoutUnit clientLeft() const { |
| return LayoutUnit(borderLeft() + |
| (shouldPlaceBlockDirectionScrollbarOnLogicalLeft() |
| ? verticalScrollbarWidth() |
| : 0)); |
| } |
| DISABLE_CFI_PERF LayoutUnit clientTop() const { |
| return LayoutUnit(borderTop()); |
| } |
| LayoutUnit clientWidth() const; |
| LayoutUnit clientHeight() const; |
| DISABLE_CFI_PERF LayoutUnit clientLogicalWidth() const { |
| return style()->isHorizontalWritingMode() ? clientWidth() : clientHeight(); |
| } |
| DISABLE_CFI_PERF LayoutUnit clientLogicalHeight() const { |
| return style()->isHorizontalWritingMode() ? clientHeight() : clientWidth(); |
| } |
| DISABLE_CFI_PERF LayoutUnit clientLogicalBottom() const { |
| return borderBefore() + clientLogicalHeight(); |
| } |
| DISABLE_CFI_PERF LayoutRect clientBoxRect() const { |
| return LayoutRect(clientLeft(), clientTop(), clientWidth(), clientHeight()); |
| } |
| |
| int pixelSnappedClientWidth() const; |
| int pixelSnappedClientHeight() const; |
| |
| // scrollWidth/scrollHeight will be the same as clientWidth/clientHeight |
| // unless the object has overflow:hidden/scroll/auto specified and also has |
| // overflow. scrollLeft/Top return the current scroll position. These methods |
| // are virtual so that objects like textareas can scroll shadow content (but |
| // pretend that they are the objects that are scrolling). |
| virtual LayoutUnit scrollLeft() const; |
| virtual LayoutUnit scrollTop() const; |
| virtual LayoutUnit scrollWidth() const; |
| virtual LayoutUnit scrollHeight() const; |
| int pixelSnappedScrollWidth() const; |
| int pixelSnappedScrollHeight() const; |
| virtual void setScrollLeft(LayoutUnit); |
| virtual void setScrollTop(LayoutUnit); |
| |
| void scrollToOffset(const DoubleSize&, |
| ScrollBehavior = ScrollBehaviorInstant); |
| void scrollByRecursively(const DoubleSize& delta); |
| // If makeVisibleInVisualViewport is set, the visual viewport will be scrolled |
| // if required to make the rect visible. |
| void scrollRectToVisible(const LayoutRect&, |
| const ScrollAlignment& alignX, |
| const ScrollAlignment& alignY, |
| ScrollType = ProgrammaticScroll, |
| bool makeVisibleInVisualViewport = true); |
| |
| LayoutRectOutsets marginBoxOutsets() const override { |
| return m_marginBoxOutsets; |
| } |
| LayoutUnit marginTop() const override { return m_marginBoxOutsets.top(); } |
| LayoutUnit marginBottom() const override { |
| return m_marginBoxOutsets.bottom(); |
| } |
| LayoutUnit marginLeft() const override { return m_marginBoxOutsets.left(); } |
| LayoutUnit marginRight() const override { return m_marginBoxOutsets.right(); } |
| void setMarginTop(LayoutUnit margin) { m_marginBoxOutsets.setTop(margin); } |
| void setMarginBottom(LayoutUnit margin) { |
| m_marginBoxOutsets.setBottom(margin); |
| } |
| void setMarginLeft(LayoutUnit margin) { m_marginBoxOutsets.setLeft(margin); } |
| void setMarginRight(LayoutUnit margin) { |
| m_marginBoxOutsets.setRight(margin); |
| } |
| |
| LayoutUnit marginLogicalLeft() const { |
| return m_marginBoxOutsets.logicalLeft(style()->getWritingMode()); |
| } |
| LayoutUnit marginLogicalRight() const { |
| return m_marginBoxOutsets.logicalRight(style()->getWritingMode()); |
| } |
| |
| LayoutUnit marginBefore( |
| const ComputedStyle* overrideStyle = nullptr) const final { |
| return m_marginBoxOutsets.before( |
| (overrideStyle ? overrideStyle : style())->getWritingMode()); |
| } |
| LayoutUnit marginAfter( |
| const ComputedStyle* overrideStyle = nullptr) const final { |
| return m_marginBoxOutsets.after( |
| (overrideStyle ? overrideStyle : style())->getWritingMode()); |
| } |
| LayoutUnit marginStart( |
| const ComputedStyle* overrideStyle = nullptr) const final { |
| const ComputedStyle* styleToUse = overrideStyle ? overrideStyle : style(); |
| return m_marginBoxOutsets.start(styleToUse->getWritingMode(), |
| styleToUse->direction()); |
| } |
| LayoutUnit marginEnd( |
| const ComputedStyle* overrideStyle = nullptr) const final { |
| const ComputedStyle* styleToUse = overrideStyle ? overrideStyle : style(); |
| return m_marginBoxOutsets.end(styleToUse->getWritingMode(), |
| styleToUse->direction()); |
| } |
| LayoutUnit marginOver() const final { |
| return m_marginBoxOutsets.over(style()->getWritingMode()); |
| } |
| LayoutUnit marginUnder() const final { |
| return m_marginBoxOutsets.under(style()->getWritingMode()); |
| } |
| void setMarginBefore(LayoutUnit value, |
| const ComputedStyle* overrideStyle = nullptr) { |
| m_marginBoxOutsets.setBefore( |
| (overrideStyle ? overrideStyle : style())->getWritingMode(), value); |
| } |
| void setMarginAfter(LayoutUnit value, |
| const ComputedStyle* overrideStyle = nullptr) { |
| m_marginBoxOutsets.setAfter( |
| (overrideStyle ? overrideStyle : style())->getWritingMode(), value); |
| } |
| void setMarginStart(LayoutUnit value, |
| const ComputedStyle* overrideStyle = nullptr) { |
| const ComputedStyle* styleToUse = overrideStyle ? overrideStyle : style(); |
| m_marginBoxOutsets.setStart(styleToUse->getWritingMode(), |
| styleToUse->direction(), value); |
| } |
| void setMarginEnd(LayoutUnit value, |
| const ComputedStyle* overrideStyle = nullptr) { |
| const ComputedStyle* styleToUse = overrideStyle ? overrideStyle : style(); |
| m_marginBoxOutsets.setEnd(styleToUse->getWritingMode(), |
| styleToUse->direction(), value); |
| } |
| |
| // The following functions are used to implement collapsing margins. |
| // All objects know their maximal positive and negative margins. The formula |
| // for computing a collapsed margin is |maxPosMargin| - |maxNegmargin|. |
| // For a non-collapsing box, such as a leaf element, this formula will simply |
| // return the margin of the element. Blocks override the maxMarginBefore and |
| // maxMarginAfter methods. |
| virtual bool isSelfCollapsingBlock() const { return false; } |
| virtual LayoutUnit collapsedMarginBefore() const { return marginBefore(); } |
| virtual LayoutUnit collapsedMarginAfter() const { return marginAfter(); } |
| LayoutRectOutsets collapsedMarginBoxLogicalOutsets() const { |
| return LayoutRectOutsets(collapsedMarginBefore(), LayoutUnit(), |
| collapsedMarginAfter(), LayoutUnit()); |
| } |
| |
| void absoluteRects(Vector<IntRect>&, |
| const LayoutPoint& accumulatedOffset) const override; |
| void absoluteQuads(Vector<FloatQuad>&) const override; |
| FloatRect localBoundingBoxRectForAccessibility() const final; |
| |
| int reflectionOffset() const; |
| // Given a rect in the object's coordinate space, returns the corresponding |
| // rect in the reflection. |
| LayoutRect reflectedRect(const LayoutRect&) const; |
| |
| void layout() override; |
| void paint(const PaintInfo&, const LayoutPoint&) const override; |
| bool nodeAtPoint(HitTestResult&, |
| const HitTestLocation& locationInContainer, |
| const LayoutPoint& accumulatedOffset, |
| HitTestAction) override; |
| |
| LayoutUnit minPreferredLogicalWidth() const override; |
| LayoutUnit maxPreferredLogicalWidth() const override; |
| |
| // FIXME: We should rename these back to overrideLogicalHeight/Width and have |
| // them store the border-box height/width like the regular height/width |
| // accessors on LayoutBox. Right now, these are different than contentHeight/ |
| // contentWidth because they still include the scrollbar height/width. |
| LayoutUnit overrideLogicalContentWidth() const; |
| LayoutUnit overrideLogicalContentHeight() const; |
| bool hasOverrideLogicalContentHeight() const; |
| bool hasOverrideLogicalContentWidth() const; |
| void setOverrideLogicalContentHeight(LayoutUnit); |
| void setOverrideLogicalContentWidth(LayoutUnit); |
| void clearOverrideSize(); |
| void clearOverrideLogicalContentHeight(); |
| void clearOverrideLogicalContentWidth(); |
| |
| LayoutUnit overrideContainingBlockContentLogicalWidth() const; |
| LayoutUnit overrideContainingBlockContentLogicalHeight() const; |
| bool hasOverrideContainingBlockLogicalWidth() const; |
| bool hasOverrideContainingBlockLogicalHeight() const; |
| void setOverrideContainingBlockContentLogicalWidth(LayoutUnit); |
| void setOverrideContainingBlockContentLogicalHeight(LayoutUnit); |
| void clearContainingBlockOverrideSize(); |
| void clearOverrideContainingBlockContentLogicalHeight(); |
| |
| LayoutUnit extraInlineOffset() const; |
| LayoutUnit extraBlockOffset() const; |
| void setExtraInlineOffset(LayoutUnit inlineOffest); |
| void setExtraBlockOffset(LayoutUnit blockOffest); |
| void clearExtraInlineAndBlockOffests(); |
| |
| LayoutSize offsetFromContainer(const LayoutObject*) const override; |
| |
| LayoutUnit adjustBorderBoxLogicalWidthForBoxSizing(float width) const; |
| LayoutUnit adjustBorderBoxLogicalHeightForBoxSizing(float height) const; |
| LayoutUnit adjustContentBoxLogicalWidthForBoxSizing(float width) const; |
| LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(float height) const; |
| |
| // ComputedMarginValues holds the actual values for margins. It ignores |
| // margin collapsing as they are handled in LayoutBlockFlow. |
| // The margins are stored in logical coordinates (see COORDINATE |
| // SYSTEMS in LayoutBoxModel) for use during layout. |
| struct ComputedMarginValues { |
| DISALLOW_NEW(); |
| ComputedMarginValues() {} |
| |
| LayoutUnit m_before; |
| LayoutUnit m_after; |
| LayoutUnit m_start; |
| LayoutUnit m_end; |
| }; |
| |
| // LogicalExtentComputedValues is used both for the |
| // block-flow and inline-direction axis. |
| struct LogicalExtentComputedValues { |
| STACK_ALLOCATED(); |
| LogicalExtentComputedValues() {} |
| |
| // This is the dimension in the measured direction |
| // (logical height or logical width). |
| LayoutUnit m_extent; |
| |
| // This is the offset in the measured direction |
| // (logical top or logical left). |
| LayoutUnit m_position; |
| |
| // |m_margins| represents the margins in the measured direction. |
| // Note that ComputedMarginValues has also the margins in |
| // the orthogonal direction to have clearer names but they are |
| // ignored in the code. |
| ComputedMarginValues m_margins; |
| }; |
| |
| // Resolve auto margins in the chosen direction of the containing block so |
| // that objects can be pushed to the start, middle or end of the containing |
| // block. |
| void computeMarginsForDirection(MarginDirection forDirection, |
| const LayoutBlock* containingBlock, |
| LayoutUnit containerWidth, |
| LayoutUnit childWidth, |
| LayoutUnit& marginStart, |
| LayoutUnit& marginEnd, |
| Length marginStartLength, |
| Length marginStartEnd) const; |
| |
| // Used to resolve margins in the containing block's block-flow direction. |
| void computeAndSetBlockDirectionMargins(const LayoutBlock* containingBlock); |
| |
| LayoutUnit offsetFromLogicalTopOfFirstPage() const; |
| |
| // The page logical offset is the object's offset from the top of the page in |
| // the page progression direction (so an x-offset in vertical text and a |
| // y-offset for horizontal text). |
| LayoutUnit pageLogicalOffset() const { |
| return m_rareData ? m_rareData->m_pageLogicalOffset : LayoutUnit(); |
| } |
| void setPageLogicalOffset(LayoutUnit); |
| |
| // Specify which page or column to associate with an offset, if said offset is |
| // exactly at a page or column boundary. |
| enum PageBoundaryRule { AssociateWithFormerPage, AssociateWithLatterPage }; |
| LayoutUnit pageLogicalHeightForOffset(LayoutUnit) const; |
| LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit, |
| PageBoundaryRule) const; |
| |
| // Calculate the strut to insert in order fit content of size |
| // |contentLogicalHeight|. |strutToNextPage| is the strut to add to |offset| |
| // to merely get to the top of the next page or column. This is what will be |
| // returned if the content can actually fit there. Otherwise, return the |
| // distance to the next fragmentainer that can fit this piece of content. |
| virtual LayoutUnit calculatePaginationStrutToFitContent( |
| LayoutUnit offset, |
| LayoutUnit strutToNextPage, |
| LayoutUnit contentLogicalHeight) const; |
| |
| void positionLineBox(InlineBox*); |
| void moveWithEdgeOfInlineContainerIfNecessary(bool isHorizontal); |
| |
| virtual InlineBox* createInlineBox(); |
| void dirtyLineBoxes(bool fullLayout); |
| |
| // For atomic inline elements, this function returns the inline box that |
| // contains us. Enables the atomic inline LayoutObject to quickly determine |
| // what line it is contained on and to easily iterate over structures on the |
| // line. |
| InlineBox* inlineBoxWrapper() const { return m_inlineBoxWrapper; } |
| void setInlineBoxWrapper(InlineBox*); |
| void deleteLineBoxWrapper(); |
| |
| void setSpannerPlaceholder(LayoutMultiColumnSpannerPlaceholder&); |
| void clearSpannerPlaceholder(); |
| LayoutMultiColumnSpannerPlaceholder* spannerPlaceholder() const final { |
| return m_rareData ? m_rareData->m_spannerPlaceholder : 0; |
| } |
| |
| // A pagination strut is the amount of space needed to push an in-flow block- |
| // level object (or float) to the logical top of the next page or column. It |
| // will be set both for forced breaks (e.g. page-break-before:always) and soft |
| // breaks (when there's not enough space in the current page / column for the |
| // object). The strut is baked into the logicalTop() of the object, so that |
| // logicalTop() - paginationStrut() == the original position in the previous |
| // column before deciding to break. |
| // |
| // Pagination struts are either set in front of a block-level box (here) or |
| // before a line (RootInlineBox::paginationStrut()). |
| LayoutUnit paginationStrut() const { |
| return m_rareData ? m_rareData->m_paginationStrut : LayoutUnit(); |
| } |
| void setPaginationStrut(LayoutUnit); |
| void resetPaginationStrut() { |
| if (m_rareData) |
| m_rareData->m_paginationStrut = LayoutUnit(); |
| } |
| |
| // Is the specified break-before or break-after value supported on this |
| // object? It needs to be in-flow all the way up to a fragmentation context |
| // that supports the specified value. |
| bool isBreakBetweenControllable(EBreak) const; |
| |
| // Is the specified break-inside value supported on this object? It needs to |
| // be contained by a fragmentation context that supports the specified value. |
| bool isBreakInsideControllable(EBreak) const; |
| |
| virtual EBreak breakAfter() const; |
| virtual EBreak breakBefore() const; |
| EBreak breakInside() const; |
| |
| // Join two adjacent break values specified on break-before and/or break- |
| // after. avoid* values win over auto values, and forced break values win over |
| // avoid* values. |firstValue| is specified on an element earlier in the flow |
| // than |secondValue|. This method is used at class A break points [1], to |
| // join the values of the previous break-after and the next break-before, to |
| // figure out whether we may, must, or should not, break at that point. It is |
| // also used when propagating break-before values from first children and |
| // break-after values on last children to their container. |
| // |
| // [1] https://drafts.csswg.org/css-break/#possible-breaks |
| static EBreak joinFragmentainerBreakValues(EBreak firstValue, |
| EBreak secondValue); |
| |
| static bool isForcedFragmentainerBreakValue(EBreak); |
| |
| EBreak classABreakPointValue(EBreak previousBreakAfterValue) const; |
| |
| // Return true if we should insert a break in front of this box. The box needs |
| // to start at a valid class A break point in order to allow a forced break. |
| // To determine whether or not to break, we also need to know the break-after |
| // value of the previous in-flow sibling. |
| bool needsForcedBreakBefore(EBreak previousBreakAfterValue) const; |
| |
| bool paintedOutputOfObjectHasNoEffectRegardlessOfSize() const override; |
| LayoutRect localOverflowRectForPaintInvalidation() const override; |
| bool mapToVisualRectInAncestorSpace( |
| const LayoutBoxModelObject* ancestor, |
| LayoutRect&, |
| VisualRectFlags = DefaultVisualRectFlags) const override; |
| |
| LayoutUnit containingBlockLogicalHeightForGetComputedStyle() const; |
| |
| LayoutUnit containingBlockLogicalWidthForContent() const override; |
| LayoutUnit containingBlockLogicalHeightForContent( |
| AvailableLogicalHeightType) const; |
| |
| LayoutUnit containingBlockAvailableLineWidth() const; |
| LayoutUnit perpendicularContainingBlockLogicalHeight() const; |
| |
| virtual void updateLogicalWidth(); |
| void updateLogicalHeight(); |
| virtual void computeLogicalHeight(LayoutUnit logicalHeight, |
| LayoutUnit logicalTop, |
| LogicalExtentComputedValues&) const; |
| // This function will compute the logical border-box height, without laying |
| // out the box. This means that the result is only "correct" when the height |
| // is explicitly specified. This function exists so that intrinsic width |
| // calculations have a way to deal with children that have orthogonal flows. |
| // When there is no explicit height, this function assumes a content height of |
| // zero (and returns just border+padding). |
| LayoutUnit computeLogicalHeightWithoutLayout() const; |
| |
| void computeLogicalWidth(LogicalExtentComputedValues&) const; |
| |
| bool stretchesToViewport() const { |
| return document().inQuirksMode() && stretchesToViewportInQuirksMode(); |
| } |
| |
| virtual LayoutSize intrinsicSize() const { return LayoutSize(); } |
| LayoutUnit intrinsicLogicalWidth() const { |
| return style()->isHorizontalWritingMode() ? intrinsicSize().width() |
| : intrinsicSize().height(); |
| } |
| LayoutUnit intrinsicLogicalHeight() const { |
| return style()->isHorizontalWritingMode() ? intrinsicSize().height() |
| : intrinsicSize().width(); |
| } |
| virtual LayoutUnit intrinsicContentLogicalHeight() const { |
| return m_intrinsicContentLogicalHeight; |
| } |
| |
| // Whether or not the element shrinks to its intrinsic width (rather than |
| // filling the width of a containing block). HTML4 buttons, <select>s, |
| // <input>s, legends, and floating/compact elements do this. |
| bool sizesLogicalWidthToFitContent(const Length& logicalWidth) const; |
| |
| LayoutUnit shrinkLogicalWidthToAvoidFloats(LayoutUnit childMarginStart, |
| LayoutUnit childMarginEnd, |
| const LayoutBlockFlow* cb) const; |
| |
| LayoutUnit computeLogicalWidthUsing(SizeType, |
| const Length& logicalWidth, |
| LayoutUnit availableLogicalWidth, |
| const LayoutBlock* containingBlock) const; |
| LayoutUnit computeLogicalHeightUsing(SizeType, |
| const Length& height, |
| LayoutUnit intrinsicContentHeight) const; |
| LayoutUnit computeContentLogicalHeight( |
| SizeType, |
| const Length& height, |
| LayoutUnit intrinsicContentHeight) const; |
| LayoutUnit computeContentAndScrollbarLogicalHeightUsing( |
| SizeType, |
| const Length& height, |
| LayoutUnit intrinsicContentHeight) const; |
| LayoutUnit computeReplacedLogicalWidthUsing(SizeType, |
| const Length& width) const; |
| LayoutUnit computeReplacedLogicalWidthRespectingMinMaxWidth( |
| LayoutUnit logicalWidth, |
| ShouldComputePreferred = ComputeActual) const; |
| LayoutUnit computeReplacedLogicalHeightUsing(SizeType, |
| const Length& height) const; |
| LayoutUnit computeReplacedLogicalHeightRespectingMinMaxHeight( |
| LayoutUnit logicalHeight) const; |
| |
| virtual LayoutUnit computeReplacedLogicalWidth( |
| ShouldComputePreferred = ComputeActual) const; |
| virtual LayoutUnit computeReplacedLogicalHeight( |
| LayoutUnit estimatedUsedWidth = LayoutUnit()) const; |
| |
| bool percentageLogicalHeightIsResolvable() const; |
| LayoutUnit computePercentageLogicalHeight(const Length& height) const; |
| |
| // Block flows subclass availableWidth/Height to handle multi column layout |
| // (shrinking the width/height available to children when laying out.) |
| LayoutUnit availableLogicalWidth() const { return contentLogicalWidth(); } |
| LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const; |
| LayoutUnit availableLogicalHeightUsing(const Length&, |
| AvailableLogicalHeightType) const; |
| |
| // There are a few cases where we need to refer specifically to the available |
| // physical width and available physical height. Relative positioning is one |
| // of those cases, since left/top offsets are physical. |
| LayoutUnit availableWidth() const { |
| return style()->isHorizontalWritingMode() |
| ? availableLogicalWidth() |
| : availableLogicalHeight(IncludeMarginBorderPadding); |
| } |
| LayoutUnit availableHeight() const { |
| return style()->isHorizontalWritingMode() |
| ? availableLogicalHeight(IncludeMarginBorderPadding) |
| : availableLogicalWidth(); |
| } |
| |
| int verticalScrollbarWidth() const; |
| int horizontalScrollbarHeight() const; |
| int scrollbarLogicalWidth() const { |
| return style()->isHorizontalWritingMode() ? verticalScrollbarWidth() |
| : horizontalScrollbarHeight(); |
| } |
| int scrollbarLogicalHeight() const { |
| return style()->isHorizontalWritingMode() ? horizontalScrollbarHeight() |
| : verticalScrollbarWidth(); |
| } |
| virtual ScrollResult scroll(ScrollGranularity, const FloatSize&); |
| bool canBeScrolledAndHasScrollableArea() const; |
| virtual bool canBeProgramaticallyScrolled() const; |
| virtual void autoscroll(const IntPoint&); |
| bool canAutoscroll() const; |
| IntSize calculateAutoscrollDirection(const IntPoint& pointInRootFrame) const; |
| static LayoutBox* findAutoscrollable(LayoutObject*); |
| virtual void stopAutoscroll() {} |
| virtual void middleClickAutoscroll(const IntPoint&); |
| |
| DISABLE_CFI_PERF bool hasAutoVerticalScrollbar() const { |
| return hasOverflowClip() && (style()->overflowY() == OverflowAuto || |
| style()->overflowY() == OverflowPagedY || |
| style()->overflowY() == OverflowOverlay); |
| } |
| DISABLE_CFI_PERF bool hasAutoHorizontalScrollbar() const { |
| return hasOverflowClip() && (style()->overflowX() == OverflowAuto || |
| style()->overflowX() == OverflowOverlay); |
| } |
| DISABLE_CFI_PERF bool scrollsOverflow() const { |
| return scrollsOverflowX() || scrollsOverflowY(); |
| } |
| virtual bool shouldPlaceBlockDirectionScrollbarOnLogicalLeft() const { |
| return style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft(); |
| } |
| |
| bool hasScrollableOverflowX() const { |
| return scrollsOverflowX() && |
| pixelSnappedScrollWidth() != pixelSnappedClientWidth(); |
| } |
| bool hasScrollableOverflowY() const { |
| return scrollsOverflowY() && |
| pixelSnappedScrollHeight() != pixelSnappedClientHeight(); |
| } |
| virtual bool scrollsOverflowX() const { |
| return hasOverflowClip() && (style()->overflowX() == OverflowScroll || |
| hasAutoHorizontalScrollbar()); |
| } |
| virtual bool scrollsOverflowY() const { |
| return hasOverflowClip() && (style()->overflowY() == OverflowScroll || |
| hasAutoVerticalScrollbar()); |
| } |
| |
| // Elements such as the <input> field override this to specify that they are |
| // scrollable outside the context of the CSS overflow style |
| virtual bool isIntrinsicallyScrollable( |
| ScrollbarOrientation orientation) const { |
| return false; |
| } |
| |
| bool hasUnsplittableScrollingOverflow() const; |
| |
| // Page / column breakability inside block-level objects. |
| enum PaginationBreakability { |
| AllowAnyBreaks, // No restrictions on breaking. May examine children to |
| // find possible break points. |
| ForbidBreaks, // Forbid breaks inside this object. Content cannot be split |
| // nicely into smaller pieces. |
| AvoidBreaks // Preferably avoid breaks. If not possible, examine children |
| // to find possible break points. |
| }; |
| PaginationBreakability getPaginationBreakability() const; |
| |
| LayoutRect localCaretRect( |
| InlineBox*, |
| int caretOffset, |
| LayoutUnit* extraWidthToEndOfLine = nullptr) override; |
| |
| virtual LayoutRect overflowClipRect( |
| const LayoutPoint& location, |
| OverlayScrollbarClipBehavior = IgnoreOverlayScrollbarSize) const; |
| LayoutRect clipRect(const LayoutPoint& location) const; |
| virtual bool hasControlClip() const { return false; } |
| virtual LayoutRect controlClipRect(const LayoutPoint&) const { |
| return LayoutRect(); |
| } |
| |
| // Returns the combination of overflow clip, contain: paint clip and CSS clip |
| // for this object, in local space. |
| LayoutRect clippingRect() const; |
| |
| virtual void paintBoxDecorationBackground(const PaintInfo&, |
| const LayoutPoint&) const; |
| virtual void paintMask(const PaintInfo&, const LayoutPoint&) const; |
| void imageChanged(WrappedImagePtr, const IntRect* = nullptr) override; |
| ResourcePriority computeResourcePriority() const final; |
| |
| void logicalExtentAfterUpdatingLogicalWidth(const LayoutUnit& logicalTop, |
| LogicalExtentComputedValues&); |
| |
| PositionWithAffinity positionForPoint(const LayoutPoint&) override; |
| |
| void removeFloatingOrPositionedChildFromBlockLists(); |
| |
| PaintLayer* enclosingFloatPaintingLayer() const; |
| |
| virtual int firstLineBoxBaseline() const { return -1; } |
| virtual int inlineBlockBaseline(LineDirectionMode) const { |
| return -1; |
| } // Returns -1 if we should skip this box when computing the baseline of an |
| // inline-block. |
| |
| virtual Node* nodeForHitTest() const { return node(); } |
| |
| bool shrinkToAvoidFloats() const; |
| virtual bool avoidsFloats() const; |
| |
| void markChildForPaginationRelayoutIfNeeded(LayoutBox& child, |
| SubtreeLayoutScope&); |
| |
| bool isWritingModeRoot() const { |
| return !parent() || |
| parent()->style()->getWritingMode() != style()->getWritingMode(); |
| } |
| bool isOrthogonalWritingModeRoot() const { |
| return parent() && |
| parent()->isHorizontalWritingMode() != isHorizontalWritingMode(); |
| } |
| void markOrthogonalWritingModeRoot(); |
| void unmarkOrthogonalWritingModeRoot(); |
| |
| bool isDeprecatedFlexItem() const { |
| return !isInline() && !isFloatingOrOutOfFlowPositioned() && parent() && |
| parent()->isDeprecatedFlexibleBox(); |
| } |
| bool isFlexItemIncludingDeprecated() const { |
| return !isInline() && !isFloatingOrOutOfFlowPositioned() && parent() && |
| parent()->isFlexibleBoxIncludingDeprecated(); |
| } |
| bool isFlexItem() const { |
| return !isInline() && !isFloatingOrOutOfFlowPositioned() && parent() && |
| parent()->isFlexibleBox(); |
| } |
| |
| bool isGridItem() const { return parent() && parent()->isLayoutGrid(); } |
| |
| LayoutUnit lineHeight( |
| bool firstLine, |
| LineDirectionMode, |
| LinePositionMode = PositionOnContainingLine) const override; |
| int baselinePosition( |
| FontBaseline, |
| bool firstLine, |
| LineDirectionMode, |
| LinePositionMode = PositionOnContainingLine) const override; |
| |
| LayoutUnit offsetLeft(const Element*) const override; |
| LayoutUnit offsetTop(const Element*) const override; |
| |
| LayoutPoint flipForWritingModeForChild(const LayoutBox* child, |
| const LayoutPoint&) const; |
| LayoutUnit flipForWritingMode(LayoutUnit position) const WARN_UNUSED_RETURN { |
| // The offset is in the block direction (y for horizontal writing modes, x |
| // for vertical writing modes). |
| if (!UNLIKELY(hasFlippedBlocksWritingMode())) |
| return position; |
| return logicalHeight() - position; |
| } |
| LayoutPoint flipForWritingMode(const LayoutPoint& position) const |
| WARN_UNUSED_RETURN { |
| if (!UNLIKELY(hasFlippedBlocksWritingMode())) |
| return position; |
| return isHorizontalWritingMode() |
| ? LayoutPoint(position.x(), m_frameRect.height() - position.y()) |
| : LayoutPoint(m_frameRect.width() - position.x(), position.y()); |
| } |
| LayoutSize flipForWritingMode(const LayoutSize& offset) const |
| WARN_UNUSED_RETURN { |
| if (!UNLIKELY(hasFlippedBlocksWritingMode())) |
| return offset; |
| return LayoutSize(m_frameRect.width() - offset.width(), offset.height()); |
| } |
| void flipForWritingMode(LayoutRect& rect) const { |
| if (!UNLIKELY(hasFlippedBlocksWritingMode())) |
| return; |
| rect.setX(m_frameRect.width() - rect.maxX()); |
| } |
| FloatPoint flipForWritingMode(const FloatPoint& position) const |
| WARN_UNUSED_RETURN { |
| if (!UNLIKELY(hasFlippedBlocksWritingMode())) |
| return position; |
| return FloatPoint(m_frameRect.width() - position.x(), position.y()); |
| } |
| void flipForWritingMode(FloatRect& rect) const { |
| if (!UNLIKELY(hasFlippedBlocksWritingMode())) |
| return; |
| rect.setX(m_frameRect.width() - rect.maxX()); |
| } |
| // These represent your location relative to your container as a physical |
| // offset. In layout related methods you almost always want the logical |
| // location (e.g. x() and y()). Passing |container| causes flipped-block |
| // flipping w.r.t. that container, or containingBlock() otherwise. |
| LayoutPoint topLeftLocation( |
| const LayoutBox* flippedBlocksContainer = nullptr) const; |
| LayoutSize topLeftLocationOffset() const { |
| return toLayoutSize(topLeftLocation()); |
| } |
| |
| LayoutRect logicalVisualOverflowRectForPropagation( |
| const ComputedStyle&) const; |
| LayoutRect visualOverflowRectForPropagation(const ComputedStyle&) const; |
| LayoutRect logicalLayoutOverflowRectForPropagation( |
| const ComputedStyle&) const; |
| LayoutRect layoutOverflowRectForPropagation(const ComputedStyle&) const; |
| |
| bool hasOverflowModel() const { return m_overflow.get(); } |
| bool hasSelfVisualOverflow() const { |
| return m_overflow && |
| !borderBoxRect().contains(m_overflow->selfVisualOverflowRect()); |
| } |
| bool hasVisualOverflow() const { |
| return m_overflow && !borderBoxRect().contains(visualOverflowRect()); |
| } |
| |
| virtual bool needsPreferredWidthsRecalculation() const; |
| |
| // See README.md for an explanation of scroll origin. |
| virtual IntSize originAdjustmentForScrollbars() const; |
| IntSize scrolledContentOffset() const; |
| |
| // Maps a rect in scrolling contents space to box space and apply overflow |
| // clip if needed. Returns true if no clipping applied or the rect actually |
| // intersects the clipping region. If edgeInclusive is true, then this method |
| // may return true even if the resulting rect has zero area. |
| bool mapScrollingContentsRectToBoxSpace( |
| LayoutRect&, |
| ApplyOverflowClipFlag, |
| VisualRectFlags = DefaultVisualRectFlags) const; |
| |
| virtual bool hasRelativeLogicalWidth() const; |
| virtual bool hasRelativeLogicalHeight() const; |
| |
| bool hasHorizontalLayoutOverflow() const { |
| if (!m_overflow) |
| return false; |
| |
| LayoutRect layoutOverflowRect = m_overflow->layoutOverflowRect(); |
| LayoutRect noOverflowRect = this->noOverflowRect(); |
| return layoutOverflowRect.x() < noOverflowRect.x() || |
| layoutOverflowRect.maxX() > noOverflowRect.maxX(); |
| } |
| |
| bool hasVerticalLayoutOverflow() const { |
| if (!m_overflow) |
| return false; |
| |
| LayoutRect layoutOverflowRect = m_overflow->layoutOverflowRect(); |
| LayoutRect noOverflowRect = this->noOverflowRect(); |
| return layoutOverflowRect.y() < noOverflowRect.y() || |
| layoutOverflowRect.maxY() > noOverflowRect.maxY(); |
| } |
| |
| virtual LayoutBox* createAnonymousBoxWithSameTypeAs( |
| const LayoutObject*) const { |
| ASSERT_NOT_REACHED(); |
| return nullptr; |
| } |
| |
| bool hasSameDirectionAs(const LayoutBox* object) const { |
| return style()->direction() == object->style()->direction(); |
| } |
| |
| ShapeOutsideInfo* shapeOutsideInfo() const; |
| |
| void markShapeOutsideDependentsForLayout() { |
| if (isFloating()) |
| removeFloatingOrPositionedChildFromBlockLists(); |
| } |
| |
| void setIntrinsicContentLogicalHeight( |
| LayoutUnit intrinsicContentLogicalHeight) const { |
| m_intrinsicContentLogicalHeight = intrinsicContentLogicalHeight; |
| } |
| |
| bool canRenderBorderImage() const; |
| |
| void mapLocalToAncestor( |
| const LayoutBoxModelObject* ancestor, |
| TransformState&, |
| MapCoordinatesFlags = ApplyContainerFlip) const override; |
| void mapAncestorToLocal(const LayoutBoxModelObject*, |
| TransformState&, |
| MapCoordinatesFlags) const override; |
| |
| void clearPreviousPaintInvalidationRects() override; |
| |
| LayoutBlock* percentHeightContainer() const { |
| return m_rareData ? m_rareData->m_percentHeightContainer : nullptr; |
| } |
| void setPercentHeightContainer(LayoutBlock*); |
| void removeFromPercentHeightContainer(); |
| void clearPercentHeightDescendants(); |
| // For snap areas, returns the snap container that owns us. |
| LayoutBox* snapContainer() const; |
| void setSnapContainer(LayoutBox*); |
| // For snap containers, returns all associated snap areas. |
| SnapAreaSet* snapAreas() const; |
| void clearSnapAreas(); |
| |
| bool hitTestClippedOutByRoundedBorder( |
| const HitTestLocation& locationInContainer, |
| const LayoutPoint& borderBoxLocation) const; |
| |
| static bool mustInvalidateFillLayersPaintOnWidthChange(const FillLayer&); |
| static bool mustInvalidateFillLayersPaintOnHeightChange(const FillLayer&); |
| |
| bool mustInvalidateBackgroundOrBorderPaintOnHeightChange() const; |
| bool mustInvalidateBackgroundOrBorderPaintOnWidthChange() const; |
| |
| // Returns true if the box intersects the viewport visible to the user. |
| bool intersectsVisibleViewport() const; |
| |
| bool hasNonCompositedScrollbars() const final; |
| |
| protected: |
| void willBeDestroyed() override; |
| |
| void insertedIntoTree() override; |
| void willBeRemovedFromTree() override; |
| |
| void styleWillChange(StyleDifference, const ComputedStyle& newStyle) override; |
| void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override; |
| void updateFromStyle() override; |
| |
| virtual ItemPosition selfAlignmentNormalBehavior() const { |
| return ItemPositionStretch; |
| } |
| |
| // Returns false if it could not cheaply compute the extent (e.g. fixed |
| // background), in which case the returned rect may be incorrect. |
| // FIXME: make this a const method once the LayoutBox reference in BoxPainter |
| // is const. |
| bool getBackgroundPaintedExtent(LayoutRect&) const; |
| virtual bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, |
| unsigned maxDepthToTest) const; |
| bool computeBackgroundIsKnownToBeObscured() const override; |
| |
| virtual void computePositionedLogicalWidth( |
| LogicalExtentComputedValues&) const; |
| |
| LayoutUnit computeIntrinsicLogicalWidthUsing( |
| const Length& logicalWidthLength, |
| LayoutUnit availableLogicalWidth, |
| LayoutUnit borderAndPadding) const; |
| virtual LayoutUnit computeIntrinsicLogicalContentHeightUsing( |
| const Length& logicalHeightLength, |
| LayoutUnit intrinsicContentHeight, |
| LayoutUnit borderAndPadding) const; |
| |
| virtual bool shouldComputeSizeAsReplaced() const { |
| return isAtomicInlineLevel() && !isInlineBlockOrInlineTable(); |
| } |
| |
| LayoutObject* splitAnonymousBoxesAroundChild(LayoutObject* beforeChild); |
| |
| virtual bool hitTestOverflowControl(HitTestResult&, |
| const HitTestLocation&, |
| const LayoutPoint&) { |
| return false; |
| } |
| virtual bool hitTestChildren(HitTestResult&, |
| const HitTestLocation& locationInContainer, |
| const LayoutPoint& accumulatedOffset, |
| HitTestAction); |
| void addLayerHitTestRects(LayerHitTestRects&, |
| const PaintLayer* currentCompositedLayer, |
| const LayoutPoint& layerOffset, |
| const LayoutRect& containerRect) const override; |
| void computeSelfHitTestRects(Vector<LayoutRect>&, |
| const LayoutPoint& layerOffset) const override; |
| |
| PaintInvalidationReason invalidatePaintIfNeeded( |
| const PaintInvalidationState&) override; |
| PaintInvalidationReason invalidatePaintIfNeeded( |
| const PaintInvalidatorContext&) const override; |
| |
| bool columnFlexItemHasStretchAlignment() const; |
| bool isStretchingColumnFlexItem() const; |
| bool hasStretchedLogicalWidth() const; |
| |
| void excludeScrollbars( |
| LayoutRect&, |
| OverlayScrollbarClipBehavior = IgnoreOverlayScrollbarSize) const; |
| |
| LayoutUnit containingBlockLogicalWidthForPositioned( |
| const LayoutBoxModelObject* containingBlock, |
| bool checkForPerpendicularWritingMode = true) const; |
| LayoutUnit containingBlockLogicalHeightForPositioned( |
| const LayoutBoxModelObject* containingBlock, |
| bool checkForPerpendicularWritingMode = true) const; |
| |
| static void computeBlockStaticDistance( |
| Length& logicalTop, |
| Length& logicalBottom, |
| const LayoutBox* child, |
| const LayoutBoxModelObject* containerBlock); |
| static void computeInlineStaticDistance( |
| Length& logicalLeft, |
| Length& logicalRight, |
| const LayoutBox* child, |
| const LayoutBoxModelObject* containerBlock, |
| LayoutUnit containerLogicalWidth); |
| static void computeLogicalLeftPositionedOffset( |
| LayoutUnit& logicalLeftPos, |
| const LayoutBox* child, |
| LayoutUnit logicalWidthValue, |
| const LayoutBoxModelObject* containerBlock, |
| LayoutUnit containerLogicalWidth); |
| static void computeLogicalTopPositionedOffset( |
| LayoutUnit& logicalTopPos, |
| const LayoutBox* child, |
| LayoutUnit logicalHeightValue, |
| const LayoutBoxModelObject* containerBlock, |
| LayoutUnit containerLogicalHeight); |
| bool skipContainingBlockForPercentHeightCalculation( |
| const LayoutBox* containingBlock) const; |
| |
| private: |
| void updateShapeOutsideInfoAfterStyleChange(const ComputedStyle&, |
| const ComputedStyle* oldStyle); |
| void updateGridPositionAfterStyleChange(const ComputedStyle*); |
| void updateScrollSnapMappingAfterStyleChange(const ComputedStyle*, |
| const ComputedStyle* oldStyle); |
| void clearScrollSnapMapping(); |
| void addScrollSnapMapping(); |
| |
| bool autoWidthShouldFitContent() const; |
| LayoutUnit shrinkToFitLogicalWidth(LayoutUnit availableLogicalWidth, |
| LayoutUnit bordersPlusPadding) const; |
| |
| bool stretchesToViewportInQuirksMode() const; |
| |
| virtual void computePositionedLogicalHeight( |
| LogicalExtentComputedValues&) const; |
| void computePositionedLogicalWidthUsing( |
| SizeType, |
| Length logicalWidth, |
| const LayoutBoxModelObject* containerBlock, |
| TextDirection containerDirection, |
| LayoutUnit containerLogicalWidth, |
| LayoutUnit bordersPlusPadding, |
| const Length& logicalLeft, |
| const Length& logicalRight, |
| const Length& marginLogicalLeft, |
| const Length& marginLogicalRight, |
| LogicalExtentComputedValues&) const; |
| void computePositionedLogicalHeightUsing( |
| SizeType, |
| Length logicalHeightLength, |
| const LayoutBoxModelObject* containerBlock, |
| LayoutUnit containerLogicalHeight, |
| LayoutUnit bordersPlusPadding, |
| LayoutUnit logicalHeight, |
| const Length& logicalTop, |
| const Length& logicalBottom, |
| const Length& marginLogicalTop, |
| const Length& marginLogicalBottom, |
| LogicalExtentComputedValues&) const; |
| |
| LayoutUnit fillAvailableMeasure(LayoutUnit availableLogicalWidth) const; |
| LayoutUnit fillAvailableMeasure(LayoutUnit availableLogicalWidth, |
| LayoutUnit& marginStart, |
| LayoutUnit& marginEnd) const; |
| |
| // Calculates the intrinsic(https://drafts.csswg.org/css-sizing-3/#intrinsic) |
| // logical widths for this layout box. |
| // |
| // intrinsicWidth is defined as: |
| // intrinsic size of content (without our border and padding) + |
| // scrollbarWidth. |
| // |
| // preferredWidth is defined as: |
| // fixedWidth OR (intrinsicWidth plus border and padding). |
| // Note: fixedWidth includes border and padding and scrollbarWidth. |
| virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, |
| LayoutUnit& maxLogicalWidth) const; |
| |
| // This function calculates the preferred widths for an object. |
| // |
| // This function is only expected to be called if |
| // the boolean preferredLogicalWidthsDirty is true. It also MUST clear the |
| // boolean before returning. |
| // |
| // See INTRINSIC SIZES / PREFERRED LOGICAL WIDTHS in LayoutObject.h for more |
| // details about those widths. |
| virtual void computePreferredLogicalWidths() { |
| clearPreferredLogicalWidthsDirty(); |
| } |
| |
| LayoutBoxRareData& ensureRareData() { |
| if (!m_rareData) |
| m_rareData = wrapUnique(new LayoutBoxRareData()); |
| return *m_rareData.get(); |
| } |
| |
| bool logicalHeightComputesAsNone(SizeType) const; |
| |
| bool isBox() const = |
| delete; // This will catch anyone doing an unnecessary check. |
| |
| void frameRectChanged(); |
| |
| virtual bool isInSelfHitTestingPhase(HitTestAction hitTestAction) const { |
| return hitTestAction == HitTestForeground; |
| } |
| |
| void updateBackgroundAttachmentFixedStatusAfterStyleChange(); |
| |
| // The CSS border box rect for this box. |
| // |
| // The rectangle is in this box's physical coordinates but with a |
| // flipped block-flow direction (see the COORDINATE SYSTEMS section |
| // in LayoutBoxModelObject). The location is the distance from this |
| // object's border edge to the container's border edge (which is not |
| // always the parent). Thus it includes any logical top/left along |
| // with this box's margins. |
| LayoutRect m_frameRect; |
| |
| // Our intrinsic height, used for min-height: min-content etc. Maintained by |
| // updateLogicalHeight. This is logicalHeight() before it is clamped to |
| // min/max. |
| mutable LayoutUnit m_intrinsicContentLogicalHeight; |
| |
| void inflateVisualRectForFilter(LayoutRect&) const; |
| void inflateVisualRectForFilterUnderContainer( |
| LayoutRect&, |
| const LayoutObject& container, |
| const LayoutBoxModelObject* ancestorToStopAt) const; |
| |
| LayoutRectOutsets m_marginBoxOutsets; |
| |
| void addSnapArea(const LayoutBox&); |
| void removeSnapArea(const LayoutBox&); |
| |
| LayoutRect debugRect() const override; |
| |
| protected: |
| // The logical width of the element if it were to break its lines at every |
| // possible opportunity. |
| // |
| // See LayoutObject::minPreferredLogicalWidth() for more details. |
| LayoutUnit m_minPreferredLogicalWidth; |
| |
| // The logical width of the element if it never breaks any lines at all. |
| // |
| // See LayoutObject::maxPreferredLogicalWidth() for more details. |
| LayoutUnit m_maxPreferredLogicalWidth; |
| |
| // Our overflow information. |
| std::unique_ptr<BoxOverflowModel> m_overflow; |
| |
| private: |
| // The inline box containing this LayoutBox, for atomic inline elements. |
| InlineBox* m_inlineBoxWrapper; |
| |
| std::unique_ptr<LayoutBoxRareData> m_rareData; |
| }; |
| |
| DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutBox, isBox()); |
| |
| inline LayoutBox* LayoutBox::previousSiblingBox() const { |
| return toLayoutBox(previousSibling()); |
| } |
| |
| inline LayoutBox* LayoutBox::previousInFlowSiblingBox() const { |
| LayoutBox* previous = previousSiblingBox(); |
| while (previous && previous->isOutOfFlowPositioned()) |
| previous = previous->previousSiblingBox(); |
| return previous; |
| } |
| |
| inline LayoutBox* LayoutBox::nextSiblingBox() const { |
| return toLayoutBox(nextSibling()); |
| } |
| |
| inline LayoutBox* LayoutBox::nextInFlowSiblingBox() const { |
| LayoutBox* next = nextSiblingBox(); |
| while (next && next->isOutOfFlowPositioned()) |
| next = next->nextSiblingBox(); |
| return next; |
| } |
| |
| inline LayoutBox* LayoutBox::parentBox() const { |
| return toLayoutBox(parent()); |
| } |
| |
| inline LayoutBox* LayoutBox::firstChildBox() const { |
| return toLayoutBox(slowFirstChild()); |
| } |
| |
| inline LayoutBox* LayoutBox::lastChildBox() const { |
| return toLayoutBox(slowLastChild()); |
| } |
| |
| inline LayoutBox* LayoutBox::previousSiblingMultiColumnBox() const { |
| ASSERT(isLayoutMultiColumnSpannerPlaceholder() || isLayoutMultiColumnSet()); |
| LayoutBox* previousBox = previousSiblingBox(); |
| if (previousBox->isLayoutFlowThread()) |
| return nullptr; |
| return previousBox; |
| } |
| |
| inline LayoutBox* LayoutBox::nextSiblingMultiColumnBox() const { |
| ASSERT(isLayoutMultiColumnSpannerPlaceholder() || isLayoutMultiColumnSet()); |
| return nextSiblingBox(); |
| } |
| |
| inline void LayoutBox::setInlineBoxWrapper(InlineBox* boxWrapper) { |
| if (boxWrapper) { |
| ASSERT(!m_inlineBoxWrapper); |
| // m_inlineBoxWrapper should already be nullptr. Deleting it is a safeguard |
| // against security issues. Otherwise, there will two line box wrappers |
| // keeping the reference to this layoutObject, and only one will be notified |
| // when the layoutObject is getting destroyed. The second line box wrapper |
| // will keep a stale reference. |
| if (UNLIKELY(m_inlineBoxWrapper != nullptr)) |
| deleteLineBoxWrapper(); |
| } |
| |
| m_inlineBoxWrapper = boxWrapper; |
| } |
| |
| inline bool LayoutBox::isForcedFragmentainerBreakValue(EBreak breakValue) { |
| return breakValue == BreakColumn || breakValue == BreakLeft || |
| breakValue == BreakPage || breakValue == BreakRecto || |
| breakValue == BreakRight || breakValue == BreakVerso; |
| } |
| |
| } // namespace blink |
| |
| #endif // LayoutBox_h |
