Source/WebCore/rendering/RenderElement.h

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  * Copyright (C) 2003, 2006, 2007, 2009, 2013 Apple Inc. All rights reserved.
   5  * Copyright (C) 2010, 2012 Google Inc. All rights reserved.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public License
  18  * along with this library; see the file COPYING.LIB.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifndef RenderElement_h
  24 #define RenderElement_h
  25
  26 #include "AnimationController.h"
  27 #include "LengthFunctions.h"
  28 #include "RenderObject.h"
  29 #include "StyleInheritedData.h"
  30
  31 namespace WebCore {
  32
  33 class ControlStates;
  34 class RenderBlock;
  35
  36 class RenderElement : public RenderObject {
  37 public:
  38     virtual ~RenderElement();
  39
  40     static RenderPtr<RenderElement> createFor(Element&, RenderStyle&&);
  41
  42     bool hasInitializedStyle() const { return m_hasInitializedStyle; }
  43
  44     const RenderStyle& style() const { return m_style; }
  45     const RenderStyle& firstLineStyle() const;
  46
  47     // FIXME: Style shouldn't be mutated.
  48     RenderStyle& mutableStyle() { return m_style; }
  49
  50     void initializeStyle();
  51
  52     // Calling with minimalStyleDifference > StyleDifferenceEqual indicates that
  53     // out-of-band state (e.g. animations) requires that styleDidChange processing
  54     // continue even if the style isn't different from the current style.
  55     void setStyle(RenderStyle&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);
  56
  57     // The pseudo element style can be cached or uncached.  Use the cached method if the pseudo element doesn't respect
  58     // any pseudo classes (and therefore has no concept of changing state).
  59     const RenderStyle* getCachedPseudoStyle(PseudoId, const RenderStyle* parentStyle = nullptr) const;
  60     RenderStyle* getMutableCachedPseudoStyle(PseudoId, const RenderStyle* parentStyle = nullptr);
  61     std::unique_ptr<RenderStyle> getUncachedPseudoStyle(const PseudoStyleRequest&, const RenderStyle* parentStyle = nullptr, const RenderStyle* ownStyle = nullptr) const;
  62
  63     // This is null for anonymous renderers.
  64     Element* element() const { return downcast<Element>(RenderObject::node()); }
  65     Element* nonPseudoElement() const { return downcast<Element>(RenderObject::nonPseudoNode()); }
  66     Element* generatingElement() const;
  67
  68     RenderObject* firstChild() const { return m_firstChild; }
  69     RenderObject* lastChild() const { return m_lastChild; }
  70
  71     bool canContainFixedPositionObjects() const;
  72     bool canContainAbsolutelyPositionedObjects() const;
  73
  74     Color selectionColor(int colorProperty) const;
  75     std::unique_ptr<RenderStyle> selectionPseudoStyle() const;
  76
  77     // Obtains the selection colors that should be used when painting a selection.
  78     Color selectionBackgroundColor() const;
  79     Color selectionForegroundColor() const;
  80     Color selectionEmphasisMarkColor() const;
  81
  82     // FIXME: Make these standalone and move to relevant files.
  83     bool isRenderLayerModelObject() const;
  84     bool isBoxModelObject() const;
  85     bool isRenderBlock() const;
  86     bool isRenderBlockFlow() const;
  87     bool isRenderReplaced() const;
  88     bool isRenderInline() const;
  89     bool isRenderNamedFlowFragmentContainer() const;
  90
  91     virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const { return true; }
  92     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = nullptr);
  93     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = nullptr) { return addChild(newChild, beforeChild); }
  94     virtual void removeChild(RenderObject&);
  95
  96     // The following functions are used when the render tree hierarchy changes to make sure layers get
  97     // properly added and removed. Since containership can be implemented by any subclass, and since a hierarchy
  98     // can contain a mixture of boxes and other object types, these functions need to be in the base class.
  99     void addLayers(RenderLayer* parentLayer);
 100     void removeLayers(RenderLayer* parentLayer);
 101     void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);
 102     RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, bool checkParent = true);
 103
 104     enum NotifyChildrenType { NotifyChildren, DontNotifyChildren };
 105     void insertChildInternal(RenderObject*, RenderObject* beforeChild, NotifyChildrenType);
 106     void removeChildInternal(RenderObject&, NotifyChildrenType);
 107
 108     virtual RenderElement* hoverAncestor() const;
 109
 110     virtual void dirtyLinesFromChangedChild(RenderObject&) { }
 111
 112     bool ancestorLineBoxDirty() const { return m_ancestorLineBoxDirty; }
 113     void setAncestorLineBoxDirty(bool f = true);
 114
 115     void setChildNeedsLayout(MarkingBehavior = MarkContainingBlockChain);
 116     void clearChildNeedsLayout();
 117     void setNeedsPositionedMovementLayout(const RenderStyle* oldStyle);
 118     void setNeedsSimplifiedNormalFlowLayout();
 119
 120     virtual void paint(PaintInfo&, const LayoutPoint&) = 0;
 121
 122     // inline-block elements paint all phases atomically. This function ensures that. Certain other elements
 123     // (grid items, flex items) require this behavior as well, and this function exists as a helper for them.
 124     // It is expected that the caller will call this function independent of the value of paintInfo.phase.
 125     void paintAsInlineBlock(PaintInfo&, const LayoutPoint&);
 126
 127     // Recursive function that computes the size and position of this object and all its descendants.
 128     virtual void layout();
 129
 130     /* This function performs a layout only if one is needed. */
 131     void layoutIfNeeded() { if (needsLayout()) layout(); }
 132
 133     // Return the renderer whose background style is used to paint the root background. Should only be called on the renderer for which isDocumentElementRenderer() is true.
 134     RenderElement& rendererForRootBackground();
 135
 136     // Used only by Element::pseudoStyleCacheIsInvalid to get a first line style based off of a
 137     // given new style, without accessing the cache.
 138     std::unique_ptr<RenderStyle> uncachedFirstLineStyle(RenderStyle*) const;
 139
 140     // Updates only the local style ptr of the object. Does not update the state of the object,
 141     // and so only should be called when the style is known not to have changed (or from setStyle).
 142     void setStyleInternal(RenderStyle&& style) { m_style = WTFMove(style); }
 143
 144     // Repaint only if our old bounds and new bounds are different. The caller may pass in newBounds and newOutlineBox if they are known.
 145     bool repaintAfterLayoutIfNeeded(const RenderLayerModelObject* repaintContainer, const LayoutRect& oldBounds, const LayoutRect& oldOutlineBox, const LayoutRect* newBoundsPtr = nullptr, const LayoutRect* newOutlineBoxPtr = nullptr);
 146
 147     bool borderImageIsLoadedAndCanBeRendered() const;
 148     bool mayCauseRepaintInsideViewport(const IntRect* visibleRect = nullptr) const;
 149
 150     // Returns true if this renderer requires a new stacking context.
 151     bool createsGroup() const { return isTransparent() || hasMask() || hasClipPath() || hasFilter() || hasBackdropFilter() || hasBlendMode(); }
 152
 153     bool isTransparent() const { return style().opacity() < 1.0f; }
 154     float opacity() const { return style().opacity(); }
 155
 156     bool visibleToHitTesting() const { return style().visibility() == VISIBLE && style().pointerEvents() != PE_NONE; }
 157
 158     bool hasBackground() const { return style().hasBackground(); }
 159     bool hasMask() const { return style().hasMask(); }
 160     bool hasClip() const { return isOutOfFlowPositioned() && style().hasClip(); }
 161     bool hasClipOrOverflowClip() const { return hasClip() || hasOverflowClip(); }
 162     bool hasClipPath() const { return style().clipPath(); }
 163     bool hasHiddenBackface() const { return style().backfaceVisibility() == BackfaceVisibilityHidden; }
 164     bool hasOutlineAnnotation() const;
 165     bool hasOutline() const { return style().hasOutline() || hasOutlineAnnotation(); }
 166     bool hasSelfPaintingLayer() const;
 167
 168     bool checkForRepaintDuringLayout() const;
 169
 170     // anchorRect() is conceptually similar to absoluteBoundingBoxRect(), but is intended for scrolling to an anchor.
 171     // For inline renderers, this gets the logical top left of the first leaf child and the logical bottom right of the
 172     // last leaf child, converts them to absolute coordinates, and makes a box out of them.
 173     LayoutRect anchorRect() const;
 174
 175     bool hasFilter() const { return style().hasFilter(); }
 176     bool hasBackdropFilter() const
 177     {
 178 #if ENABLE(FILTERS_LEVEL_2)
 179         return style().hasBackdropFilter();
 180 #else
 181         return false;
 182 #endif
 183     }
 184
 185
 186 #if ENABLE(CSS_COMPOSITING)
 187     bool hasBlendMode() const { return style().hasBlendMode(); }
 188 #else
 189     bool hasBlendMode() const { return false; }
 190 #endif
 191
 192 #if ENABLE(CSS_SHAPES)
 193     bool hasShapeOutside() const { return style().shapeOutside(); }
 194 #else
 195     bool hasShapeOutside() const { return false; }
 196 #endif
 197
 198     void registerForVisibleInViewportCallback();
 199     void unregisterForVisibleInViewportCallback();
 200     void visibleInViewportStateChanged(VisibleInViewportState);
 201
 202     bool repaintForPausedImageAnimationsIfNeeded(const IntRect& visibleRect);
 203     bool hasPausedImageAnimations() const { return m_hasPausedImageAnimations; }
 204     void setHasPausedImageAnimations(bool b) { m_hasPausedImageAnimations = b; }
 205
 206     RenderNamedFlowThread* renderNamedFlowThreadWrapper();
 207
 208     void setRenderBoxNeedsLazyRepaint(bool b) { m_renderBoxNeedsLazyRepaint = b; }
 209     bool renderBoxNeedsLazyRepaint() const { return m_renderBoxNeedsLazyRepaint; }
 210
 211     bool hasCounterNodeMap() const { return m_hasCounterNodeMap; }
 212     void setHasCounterNodeMap(bool f) { m_hasCounterNodeMap = f; }
 213
 214     bool isCSSAnimating() const { return m_isCSSAnimating; }
 215     void setIsCSSAnimating(bool b) { m_isCSSAnimating = b; }
 216
 217     const RenderElement* enclosingRendererWithTextDecoration(TextDecoration, bool firstLine) const;
 218     void drawLineForBoxSide(GraphicsContext&, const FloatRect&, BoxSide, Color, EBorderStyle, float adjacentWidth1, float adjacentWidth2, bool antialias = false) const;
 219
 220     bool childRequiresTable(const RenderObject& child) const;
 221     bool hasContinuation() const { return m_hasContinuation; }
 222
 223 #if ENABLE(IOS_TEXT_AUTOSIZING)
 224     void adjustComputedFontSizesOnBlocks(float size, float visibleWidth);
 225     WEBCORE_EXPORT void resetTextAutosizing();
 226 #endif
 227     RenderBlock* containingBlockForFixedPosition() const;
 228     RenderBlock* containingBlockForAbsolutePosition() const;
 229
 230     RespectImageOrientationEnum shouldRespectImageOrientation() const;
 231
 232 protected:
 233     enum BaseTypeFlag {
 234         RenderLayerModelObjectFlag  = 1 << 0,
 235         RenderBoxModelObjectFlag    = 1 << 1,
 236         RenderInlineFlag            = 1 << 2,
 237         RenderReplacedFlag          = 1 << 3,
 238         RenderBlockFlag             = 1 << 4,
 239         RenderBlockFlowFlag         = 1 << 5,
 240     };
 241
 242     typedef unsigned BaseTypeFlags;
 243
 244     RenderElement(Element&, RenderStyle&&, BaseTypeFlags);
 245     RenderElement(Document&, RenderStyle&&, BaseTypeFlags);
 246
 247     bool layerCreationAllowedForSubtree() const;
 248
 249     enum StylePropagationType { PropagateToAllChildren, PropagateToBlockChildrenOnly };
 250     void propagateStyleToAnonymousChildren(StylePropagationType);
 251
 252     LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue) const;
 253     LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue) const;
 254
 255     void setFirstChild(RenderObject* child) { m_firstChild = child; }
 256     void setLastChild(RenderObject* child) { m_lastChild = child; }
 257     void destroyLeftoverChildren();
 258
 259     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle);
 260     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
 261
 262     void insertedIntoTree() override;
 263     void willBeRemovedFromTree() override;
 264     void willBeDestroyed() override;
 265
 266     void setRenderInlineAlwaysCreatesLineBoxes(bool b) { m_renderInlineAlwaysCreatesLineBoxes = b; }
 267     bool renderInlineAlwaysCreatesLineBoxes() const { return m_renderInlineAlwaysCreatesLineBoxes; }
 268
 269     void setHasContinuation(bool b) { m_hasContinuation = b; }
 270
 271     void setRenderBlockHasMarginBeforeQuirk(bool b) { m_renderBlockHasMarginBeforeQuirk = b; }
 272     void setRenderBlockHasMarginAfterQuirk(bool b) { m_renderBlockHasMarginAfterQuirk = b; }
 273     void setRenderBlockShouldForceRelayoutChildren(bool b) { m_renderBlockShouldForceRelayoutChildren = b; }
 274     bool renderBlockHasMarginBeforeQuirk() const { return m_renderBlockHasMarginBeforeQuirk; }
 275     bool renderBlockHasMarginAfterQuirk() const { return m_renderBlockHasMarginAfterQuirk; }
 276     bool renderBlockShouldForceRelayoutChildren() const { return m_renderBlockShouldForceRelayoutChildren; }
 277
 278     void setRenderBlockFlowLineLayoutPath(unsigned u) { m_renderBlockFlowLineLayoutPath = u; }
 279     void setRenderBlockFlowHasMarkupTruncation(bool b) { m_renderBlockFlowHasMarkupTruncation = b; }
 280     unsigned renderBlockFlowLineLayoutPath() const { return m_renderBlockFlowLineLayoutPath; }
 281     bool renderBlockFlowHasMarkupTruncation() const { return m_renderBlockFlowHasMarkupTruncation; }
 282
 283     void paintFocusRing(PaintInfo&, const RenderStyle&, const Vector<LayoutRect>& focusRingRects);
 284     void paintOutline(PaintInfo&, const LayoutRect&);
 285     void updateOutlineAutoAncestor(bool hasOutlineAuto);
 286
 287 private:
 288     RenderElement(ContainerNode&, RenderStyle&&, BaseTypeFlags);
 289     void node() const = delete;
 290     void nonPseudoNode() const = delete;
 291     void generatingNode() const = delete;
 292     void isText() const = delete;
 293     void isRenderElement() const = delete;
 294
 295     RenderObject* firstChildSlow() const final { return firstChild(); }
 296     RenderObject* lastChildSlow() const final { return lastChild(); }
 297
 298     // Called when an object that was floating or positioned becomes a normal flow object
 299     // again.  We have to make sure the render tree updates as needed to accommodate the new
 300     // normal flow object.
 301     void handleDynamicFloatPositionChange();
 302     void removeAnonymousWrappersForInlinesIfNecessary();
 303
 304     bool shouldRepaintForStyleDifference(StyleDifference) const;
 305     bool hasImmediateNonWhitespaceTextChildOrBorderOrOutline() const;
 306
 307     void updateFillImages(const FillLayer*, const FillLayer*);
 308     void updateImage(StyleImage*, StyleImage*);
 309 #if ENABLE(CSS_SHAPES)
 310     void updateShapeImage(const ShapeValue*, const ShapeValue*);
 311 #endif
 312
 313     StyleDifference adjustStyleDifference(StyleDifference, unsigned contextSensitiveProperties) const;
 314     const RenderStyle* cachedFirstLineStyle() const;
 315
 316     void newImageAnimationFrameAvailable(CachedImage&) final;
 317
 318     bool getLeadingCorner(FloatPoint& output) const;
 319     bool getTrailingCorner(FloatPoint& output) const;
 320
 321     void clearLayoutRootIfNeeded() const;
 322
 323     bool shouldWillChangeCreateStackingContext() const;
 324     void issueRepaintForOutlineAuto(float outlineSize);
 325
 326     unsigned m_baseTypeFlags : 6;
 327     unsigned m_ancestorLineBoxDirty : 1;
 328     unsigned m_hasInitializedStyle : 1;
 329
 330     unsigned m_renderInlineAlwaysCreatesLineBoxes : 1;
 331     unsigned m_renderBoxNeedsLazyRepaint : 1;
 332     unsigned m_hasPausedImageAnimations : 1;
 333     unsigned m_hasCounterNodeMap : 1;
 334     unsigned m_isCSSAnimating : 1;
 335     unsigned m_hasContinuation : 1;
 336
 337     unsigned m_renderBlockHasMarginBeforeQuirk : 1;
 338     unsigned m_renderBlockHasMarginAfterQuirk : 1;
 339     unsigned m_renderBlockShouldForceRelayoutChildren : 1;
 340     unsigned m_renderBlockFlowHasMarkupTruncation : 1;
 341     unsigned m_renderBlockFlowLineLayoutPath : 2;
 342
 343     VisibleInViewportState m_visibleInViewportState { VisibilityUnknown };
 344
 345     RenderObject* m_firstChild;
 346     RenderObject* m_lastChild;
 347
 348     RenderStyle m_style;
 349
 350     // FIXME: Get rid of this hack.
 351     // Store state between styleWillChange and styleDidChange
 352     static bool s_affectsParentBlock;
 353     static bool s_noLongerAffectsParentBlock;
 354 };
 355
 356 inline void RenderElement::setAncestorLineBoxDirty(bool f)
 357 {
 358     m_ancestorLineBoxDirty = f;
 359     if (m_ancestorLineBoxDirty)
 360         setNeedsLayout();
 361 }
 362
 363 inline void RenderElement::setChildNeedsLayout(MarkingBehavior markParents)
 364 {
 365     ASSERT(!isSetNeedsLayoutForbidden());
 366     if (normalChildNeedsLayout())
 367         return;
 368     setNormalChildNeedsLayoutBit(true);
 369     if (markParents == MarkContainingBlockChain)
 370         markContainingBlocksForLayout();
 371 }
 372
 373 inline LayoutUnit RenderElement::valueForLength(const Length& length, LayoutUnit maximumValue) const
 374 {
 375     return WebCore::valueForLength(length, maximumValue);
 376 }
 377
 378 inline LayoutUnit RenderElement::minimumValueForLength(const Length& length, LayoutUnit maximumValue) const
 379 {
 380     return WebCore::minimumValueForLength(length, maximumValue);
 381 }
 382
 383 inline bool RenderElement::isRenderLayerModelObject() const
 384 {
 385     return m_baseTypeFlags & RenderLayerModelObjectFlag;
 386 }
 387
 388 inline bool RenderElement::isBoxModelObject() const
 389 {
 390     return m_baseTypeFlags & RenderBoxModelObjectFlag;
 391 }
 392
 393 inline bool RenderElement::isRenderBlock() const
 394 {
 395     return m_baseTypeFlags & RenderBlockFlag;
 396 }
 397
 398 inline bool RenderElement::isRenderBlockFlow() const
 399 {
 400     return m_baseTypeFlags & RenderBlockFlowFlag;
 401 }
 402
 403 inline bool RenderElement::isRenderReplaced() const
 404 {
 405     return m_baseTypeFlags & RenderReplacedFlag;
 406 }
 407
 408 inline bool RenderElement::isRenderInline() const
 409 {
 410     return m_baseTypeFlags & RenderInlineFlag;
 411 }
 412
 413 inline Element* RenderElement::generatingElement() const
 414 {
 415     if (parent() && isRenderNamedFlowFragment())
 416         return parent()->generatingElement();
 417     return downcast<Element>(RenderObject::generatingNode());
 418 }
 419
 420 inline bool RenderElement::canContainFixedPositionObjects() const
 421 {
 422     return isRenderView()
 423         || (hasTransform() && isRenderBlock())
 424         || isSVGForeignObject()
 425         || isOutOfFlowRenderFlowThread();
 426 }
 427
 428 inline bool RenderElement::canContainAbsolutelyPositionedObjects() const
 429 {
 430     return style().position() != StaticPosition
 431         || (isRenderBlock() && hasTransformRelatedProperty())
 432         || isSVGForeignObject()
 433         || isRenderView();
 434 }
 435
 436 inline bool RenderObject::isRenderLayerModelObject() const
 437 {
 438     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderLayerModelObject();
 439 }
 440
 441 inline bool RenderObject::isBoxModelObject() const
 442 {
 443     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isBoxModelObject();
 444 }
 445
 446 inline bool RenderObject::isRenderBlock() const
 447 {
 448     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderBlock();
 449 }
 450
 451 inline bool RenderObject::isRenderBlockFlow() const
 452 {
 453     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderBlockFlow();
 454 }
 455
 456 inline bool RenderObject::isRenderReplaced() const
 457 {
 458     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderReplaced();
 459 }
 460
 461 inline bool RenderObject::isRenderInline() const
 462 {
 463     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderInline();
 464 }
 465
 466 inline const RenderStyle& RenderObject::style() const
 467 {
 468     if (isText())
 469         return m_parent->style();
 470     return downcast<RenderElement>(*this).style();
 471 }
 472
 473 inline const RenderStyle& RenderObject::firstLineStyle() const
 474 {
 475     if (isText())
 476         return m_parent->firstLineStyle();
 477     return downcast<RenderElement>(*this).firstLineStyle();
 478 }
 479
 480 inline RenderElement* ContainerNode::renderer() const
 481 {
 482     return downcast<RenderElement>(Node::renderer());
 483 }
 484
 485 inline int adjustForAbsoluteZoom(int value, const RenderElement& renderer)
 486 {
 487     return adjustForAbsoluteZoom(value, renderer.style());
 488 }
 489
 490 inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const RenderElement& renderer)
 491 {
 492     return adjustLayoutUnitForAbsoluteZoom(value, renderer.style());
 493 }
 494
 495 } // namespace WebCore
 496
 497 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderElement, isRenderElement())
 498
 499 #endif // RenderElement_h