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