/* * Copyright (C) 1999 Lars Knoll (knoll@kde.org) * (C) 1999 Antti Koivisto (koivisto@kde.org) * Copyright (C) 2003, 2006, 2007, 2009 Apple Inc. All rights reserved. * Copyright (C) 2010 Google 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 LayoutBoxModelObject_h #define LayoutBoxModelObject_h #include "core/CoreExport.h" #include "core/layout/LayoutObject.h" #include "core/style/ShadowData.h" #include "platform/geometry/LayoutRect.h" namespace blink { class LineLayoutBoxModel; class PaintLayer; class PaintLayerScrollableArea; enum PaintLayerType { NoPaintLayer, NormalPaintLayer, // A forced or overflow clip layer is required for bookkeeping purposes, // but does not force a layer to be self painting. OverflowClipPaintLayer, ForcedPaintLayer }; // Modes for some of the line-related functions. enum LinePositionMode { PositionOnContainingLine, PositionOfInteriorLineBoxes }; enum LineDirectionMode { HorizontalLine, VerticalLine }; typedef unsigned BorderEdgeFlags; enum BackgroundBleedAvoidance { BackgroundBleedNone, BackgroundBleedShrinkBackground, BackgroundBleedClipOnly, BackgroundBleedClipLayer, }; enum ContentChangeType { ImageChanged, CanvasChanged, CanvasContextChanged }; class InlineFlowBox; // This class is the base class for all CSS objects. // // All CSS objects follow the box model object. See THE BOX MODEL section in // LayoutBox for more information. // // This class actually doesn't have the box model but it exposes some common // functions or concepts that sub-classes can extend upon. For example, there // are accessors for margins, borders, paddings and borderBoundingBox(). // // The reason for this partial implementation is that the 2 classes inheriting // from it (LayoutBox and LayoutInline) have different requirements but need to // have a PaintLayer. // For a full implementation of the box model, see LayoutBox. // // An important member of this class is PaintLayer. This class is // central to painting and hit-testing (see its class comment). // PaintLayers are instantiated for several reasons based on the // return value of layerTypeRequired(). // Interestingly, most SVG objects inherit from LayoutSVGModelObject and thus // can't have a PaintLayer. This is an unfortunate artifact of our // design as it limits code sharing and prevents hardware accelerating SVG // (the current design require a PaintLayer for compositing). // // // ***** COORDINATE SYSTEMS ***** // // In order to fully understand LayoutBoxModelObject and the inherited classes, // we need to introduce the concept of coordinate systems. // There is 3 main coordinate systems: // - physical coordinates: it is the coordinate system used for painting and // correspond to physical direction as seen on the physical display (screen, // printed page). In CSS, 'top', 'right', 'bottom', 'left' are all in physical // coordinates. The code matches this convention too. // // - logical coordinates: this is the coordinate system used for layout. It is // determined by 'writing-mode' and 'direction'. Any property using 'before', // 'after', 'start' or 'end' is in logical coordinates. Those are also named // respectively 'logical top', 'logical bottom', 'logical left' and // 'logical right'. // // Example with writing-mode: vertical-rl; direction: ltr; // // 'top' / 'start' side // // block-flow direction // <------------------------------------ | // ------------------------------------- | // | c | s | | // 'left' | o | o | | inline 'right' // / | n | m | | direction / // 'after' | t | e | | 'before' // side | e | | | side // | n | | | // | t | | | // ------------------------------------- v // // 'bottom' / 'end' side // // See https://drafts.csswg.org/css-writing-modes-3/#text-flow for some // extra details. // // - physical coordinates with flipped block-flow direction: those are physical // coordinates but we flipped the block direction. See // LayoutBox::noOverflowRect. // TODO(jchaffraix): I don't fully understand why we need this coordinate // system someone should fill in those details. class CORE_EXPORT LayoutBoxModelObject : public LayoutObject { public: LayoutBoxModelObject(ContainerNode*); ~LayoutBoxModelObject() override; // This is the only way layers should ever be destroyed. void destroyLayer(); LayoutSize relativePositionOffset() const; LayoutSize relativePositionLogicalOffset() const { return style()->isHorizontalWritingMode() ? relativePositionOffset() : relativePositionOffset().transposedSize(); } LayoutSize offsetForInFlowPosition() const; // 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). virtual LayoutUnit offsetLeft() const; virtual LayoutUnit offsetTop() const; virtual LayoutUnit offsetWidth() const = 0; virtual LayoutUnit offsetHeight() const = 0; int pixelSnappedOffsetLeft() const { return roundToInt(offsetLeft()); } int pixelSnappedOffsetTop() const { return roundToInt(offsetTop()); } virtual int pixelSnappedOffsetWidth() const; virtual int pixelSnappedOffsetHeight() const; bool hasSelfPaintingLayer() const; PaintLayer* layer() const { return m_layer.get(); } PaintLayerScrollableArea* getScrollableArea() const; virtual void updateFromStyle(); // The type of PaintLayer to instantiate. // Any value returned from this function other than NoPaintLayer // will populate |m_layer|. virtual PaintLayerType layerTypeRequired() const = 0; // This will work on inlines to return the bounding box of all of the lines' border boxes. virtual IntRect borderBoundingBox() const = 0; virtual LayoutRect visualOverflowRect() const = 0; // Checks if this box, or any of it's descendants, or any of it's continuations, // will take up space in the layout of the page. bool hasNonEmptyLayoutSize() const; bool usesCompositedScrolling() const; // These return the CSS computed padding values. LayoutUnit computedCSSPaddingTop() const { return computedCSSPadding(style()->paddingTop()); } LayoutUnit computedCSSPaddingBottom() const { return computedCSSPadding(style()->paddingBottom()); } LayoutUnit computedCSSPaddingLeft() const { return computedCSSPadding(style()->paddingLeft()); } LayoutUnit computedCSSPaddingRight() const { return computedCSSPadding(style()->paddingRight()); } LayoutUnit computedCSSPaddingBefore() const { return computedCSSPadding(style()->paddingBefore()); } LayoutUnit computedCSSPaddingAfter() const { return computedCSSPadding(style()->paddingAfter()); } LayoutUnit computedCSSPaddingStart() const { return computedCSSPadding(style()->paddingStart()); } LayoutUnit computedCSSPaddingEnd() const { return computedCSSPadding(style()->paddingEnd()); } LayoutUnit computedCSSPaddingOver() const { return computedCSSPadding(style()->paddingOver()); } LayoutUnit computedCSSPaddingUnder() const { return computedCSSPadding(style()->paddingUnder()); } // These functions are used during layout. // - Table cells override them to include the intrinsic padding (see // explanations in LayoutTableCell). // - Table override them to exclude padding with collapsing borders. virtual LayoutUnit paddingTop() const { return computedCSSPaddingTop(); } virtual LayoutUnit paddingBottom() const { return computedCSSPaddingBottom(); } virtual LayoutUnit paddingLeft() const { return computedCSSPaddingLeft(); } virtual LayoutUnit paddingRight() const { return computedCSSPaddingRight(); } virtual LayoutUnit paddingBefore() const { return computedCSSPaddingBefore(); } virtual LayoutUnit paddingAfter() const { return computedCSSPaddingAfter(); } virtual LayoutUnit paddingStart() const { return computedCSSPaddingStart(); } virtual LayoutUnit paddingEnd() const { return computedCSSPaddingEnd(); } LayoutUnit paddingOver() const { return computedCSSPaddingOver(); } LayoutUnit paddingUnder() const { return computedCSSPaddingUnder(); } virtual int borderTop() const { return style()->borderTopWidth(); } virtual int borderBottom() const { return style()->borderBottomWidth(); } virtual int borderLeft() const { return style()->borderLeftWidth(); } virtual int borderRight() const { return style()->borderRightWidth(); } virtual int borderBefore() const { return style()->borderBeforeWidth(); } virtual int borderAfter() const { return style()->borderAfterWidth(); } virtual int borderStart() const { return style()->borderStartWidth(); } virtual int borderEnd() const { return style()->borderEndWidth(); } int borderOver() const { return style()->borderOverWidth(); } int borderUnder() const { return style()->borderUnderWidth(); } int borderWidth() const { return borderLeft() + borderRight(); } int borderHeight() const { return borderTop() + borderBottom(); } // Insets from the border box to the inside of the border. LayoutRectOutsets borderInsets() const { return LayoutRectOutsets(-borderTop(), -borderRight(), -borderBottom(), -borderLeft()); } bool hasBorderOrPadding() const { return style()->hasBorder() || style()->hasPadding(); } LayoutUnit borderAndPaddingStart() const { return borderStart() + paddingStart(); } LayoutUnit borderAndPaddingBefore() const { return borderBefore() + paddingBefore(); } LayoutUnit borderAndPaddingAfter() const { return borderAfter() + paddingAfter(); } LayoutUnit borderAndPaddingOver() const { return borderOver() + paddingOver(); } LayoutUnit borderAndPaddingUnder() const { return borderUnder() + paddingUnder(); } LayoutUnit borderAndPaddingHeight() const { return borderTop() + borderBottom() + paddingTop() + paddingBottom(); } LayoutUnit borderAndPaddingWidth() const { return borderLeft() + borderRight() + paddingLeft() + paddingRight(); } LayoutUnit borderAndPaddingLogicalHeight() const { return hasBorderOrPadding() ? borderAndPaddingBefore() + borderAndPaddingAfter() : LayoutUnit(); } LayoutUnit borderAndPaddingLogicalWidth() const { return borderStart() + borderEnd() + paddingStart() + paddingEnd(); } LayoutUnit borderAndPaddingLogicalLeft() const { return style()->isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); } LayoutUnit borderLogicalLeft() const { return LayoutUnit(style()->isHorizontalWritingMode() ? borderLeft() : borderTop()); } LayoutUnit paddingLogicalWidth() const { return paddingStart() + paddingEnd(); } LayoutUnit paddingLogicalHeight() const { return paddingBefore() + paddingAfter(); } virtual LayoutRectOutsets marginBoxOutsets() const = 0; virtual LayoutUnit marginTop() const = 0; virtual LayoutUnit marginBottom() const = 0; virtual LayoutUnit marginLeft() const = 0; virtual LayoutUnit marginRight() const = 0; virtual LayoutUnit marginBefore(const ComputedStyle* otherStyle = nullptr) const = 0; virtual LayoutUnit marginAfter(const ComputedStyle* otherStyle = nullptr) const = 0; virtual LayoutUnit marginStart(const ComputedStyle* otherStyle = nullptr) const = 0; virtual LayoutUnit marginEnd(const ComputedStyle* otherStyle = nullptr) const = 0; virtual LayoutUnit marginOver() const = 0; virtual LayoutUnit marginUnder() const = 0; LayoutUnit marginHeight() const { return marginTop() + marginBottom(); } LayoutUnit marginWidth() const { return marginLeft() + marginRight(); } LayoutUnit marginLogicalHeight() const { return marginBefore() + marginAfter(); } LayoutUnit marginLogicalWidth() const { return marginStart() + marginEnd(); } bool hasInlineDirectionBordersPaddingOrMargin() const { return hasInlineDirectionBordersOrPadding() || marginStart() || marginEnd(); } bool hasInlineDirectionBordersOrPadding() const { return borderStart() || borderEnd() || paddingStart() || paddingEnd(); } virtual LayoutUnit containingBlockLogicalWidthForContent() const; virtual void childBecameNonInline(LayoutObject* /*child*/) { } virtual bool boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance, const InlineFlowBox* = nullptr) const; // Overridden by subclasses to determine line height and baseline position. virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const = 0; virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const = 0; const LayoutObject* pushMappingToContainer(const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap&) const override; void setSelectionState(SelectionState) override; void contentChanged(ContentChangeType); bool hasAcceleratedCompositing() const; void computeLayerHitTestRects(LayerHitTestRects&) const override; // Returns true if the background is painted opaque in the given rect. // The query rect is given in local coordinate system. virtual bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const { return false; } void invalidateTreeIfNeeded(const PaintInvalidationState&) override; // Indicate that the contents of this layoutObject need to be repainted. Only has an effect if compositing is being used, void setBackingNeedsPaintInvalidationInRect(const LayoutRect&, PaintInvalidationReason) const; // r is in the coordinate space of this layout object void invalidateDisplayItemClientOnBacking(const DisplayItemClient&, PaintInvalidationReason) const; // http://www.w3.org/TR/css3-background/#body-background // root element with no background steals background from its first child. // The used background for such body element should be the initial value. (i.e. transparent) bool backgroundStolenForBeingBody(const ComputedStyle* rootElementStyle = nullptr) const; protected: void willBeDestroyed() override; LayoutPoint adjustedPositionRelativeToOffsetParent(const LayoutPoint&) const; bool calculateHasBoxDecorations() const; // Returns the continuation associated with |this|. // Returns nullptr if no continuation is associated with |this|. // // See the section about CONTINUATIONS AND ANONYMOUS LAYOUTBLOCKFLOWS in // LayoutInline for more details about them. // // Our implementation uses a HashMap to store them to avoid paying the cost // for each LayoutBoxModelObject (|continuationMap| in the cpp file). LayoutBoxModelObject* continuation() const; // Set the next link in the continuation chain. // // See continuation above for more details. void setContinuation(LayoutBoxModelObject*); LayoutRect localCaretRectForEmptyElement(LayoutUnit width, LayoutUnit textIndentOffset); bool hasAutoHeightOrContainingBlockWithAutoHeight() const; LayoutBlock* containingBlockForAutoHeightDetection(Length logicalHeight) const; void addOutlineRectsForNormalChildren(Vector&, const LayoutPoint& additionalOffset, IncludeBlockVisualOverflowOrNot) const; void addOutlineRectsForDescendant(const LayoutObject& descendant, Vector&, const LayoutPoint& additionalOffset, IncludeBlockVisualOverflowOrNot) const; void addLayerHitTestRects(LayerHitTestRects&, const PaintLayer*, const LayoutPoint&, const LayoutRect&) const override; void styleWillChange(StyleDifference, const ComputedStyle& newStyle) override; void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override; public: // These functions are only used internally to manipulate the layout tree structure via remove/insert/appendChildNode. // Since they are typically called only to move objects around within anonymous blocks (which only have layers in // the case of column spans), the default for fullRemoveInsert is false rather than true. void moveChildTo(LayoutBoxModelObject* toBoxModelObject, LayoutObject* child, LayoutObject* beforeChild, bool fullRemoveInsert = false); void moveChildTo(LayoutBoxModelObject* toBoxModelObject, LayoutObject* child, bool fullRemoveInsert = false) { moveChildTo(toBoxModelObject, child, 0, fullRemoveInsert); } void moveAllChildrenTo(LayoutBoxModelObject* toBoxModelObject, bool fullRemoveInsert = false) { moveAllChildrenTo(toBoxModelObject, 0, fullRemoveInsert); } void moveAllChildrenTo(LayoutBoxModelObject* toBoxModelObject, LayoutObject* beforeChild, bool fullRemoveInsert = false) { moveChildrenTo(toBoxModelObject, slowFirstChild(), 0, beforeChild, fullRemoveInsert); } // Move all of the kids from |startChild| up to but excluding |endChild|. 0 can be passed as the |endChild| to denote // that all the kids from |startChild| onwards should be moved. void moveChildrenTo(LayoutBoxModelObject* toBoxModelObject, LayoutObject* startChild, LayoutObject* endChild, bool fullRemoveInsert = false) { moveChildrenTo(toBoxModelObject, startChild, endChild, 0, fullRemoveInsert); } virtual void moveChildrenTo(LayoutBoxModelObject* toBoxModelObject, LayoutObject* startChild, LayoutObject* endChild, LayoutObject* beforeChild, bool fullRemoveInsert = false); private: void createLayer(PaintLayerType); LayoutUnit computedCSSPadding(const Length&) const; bool isBoxModelObject() const final { return true; } // The PaintLayer associated with this object. // |m_layer| can be nullptr depending on the return value of layerTypeRequired(). OwnPtr m_layer; }; DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutBoxModelObject, isBoxModelObject()); } // namespace blink #endif // LayoutBoxModelObject_h