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