Reduce constructor copypasta in RenderText and RenderElement.
[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 "RenderObject.h"
27
28 namespace WebCore {
29
30 class ControlStates;
31
32 class RenderElement : public RenderObject {
33 public:
34     virtual ~RenderElement();
35
36     static RenderPtr<RenderElement> createFor(Element&, PassRef<RenderStyle>);
37
38     bool hasInitializedStyle() const { return m_hasInitializedStyle; }
39
40     RenderStyle& style() const { return const_cast<RenderStyle&>(m_style.get()); }
41     RenderStyle& firstLineStyle() const;
42
43     void initializeStyle();
44
45     void setStyle(PassRef<RenderStyle>);
46     // Called to update a style that is allowed to trigger animations.
47     void setAnimatableStyle(PassRef<RenderStyle>);
48
49     // This is null for anonymous renderers.
50     Element* element() const { return toElement(RenderObject::node()); }
51     Element* nonPseudoElement() const { return toElement(RenderObject::nonPseudoNode()); }
52     Element* generatingElement() const;
53
54     RenderObject* firstChild() const { return m_firstChild; }
55     RenderObject* lastChild() const { return m_lastChild; }
56
57     // FIXME: Make these standalone and move to relevant files.
58     bool isRenderLayerModelObject() const;
59     bool isBoxModelObject() const;
60     bool isRenderBlock() const;
61     bool isRenderBlockFlow() const;
62     bool isRenderReplaced() const;
63     bool isRenderInline() const;
64     bool isRenderNamedFlowFragmentContainer() const;
65
66     virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const { return true; }
67     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
68     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0) { return addChild(newChild, beforeChild); }
69     virtual void removeChild(RenderObject&);
70
71     // The following functions are used when the render tree hierarchy changes to make sure layers get
72     // properly added and removed. Since containership can be implemented by any subclass, and since a hierarchy
73     // can contain a mixture of boxes and other object types, these functions need to be in the base class.
74     void addLayers(RenderLayer* parentLayer);
75     void removeLayers(RenderLayer* parentLayer);
76     void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);
77     RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, bool checkParent = true);
78
79     enum NotifyChildrenType { NotifyChildren, DontNotifyChildren };
80     void insertChildInternal(RenderObject*, RenderObject* beforeChild, NotifyChildrenType);
81     void removeChildInternal(RenderObject&, NotifyChildrenType);
82
83     virtual RenderElement* hoverAncestor() const;
84
85     virtual void dirtyLinesFromChangedChild(RenderObject*) { }
86
87     bool ancestorLineBoxDirty() const { return m_ancestorLineBoxDirty; }
88     void setAncestorLineBoxDirty(bool f = true);
89
90     void setChildNeedsLayout(MarkingBehavior = MarkContainingBlockChain);
91     void clearChildNeedsLayout();
92     void setNeedsPositionedMovementLayout(const RenderStyle* oldStyle);
93     void setNeedsSimplifiedNormalFlowLayout();
94
95     virtual void paint(PaintInfo&, const LayoutPoint&) = 0;
96
97     // Recursive function that computes the size and position of this object and all its descendants.
98     virtual void layout();
99
100     /* This function performs a layout only if one is needed. */
101     void layoutIfNeeded() { if (needsLayout()) layout(); }
102
103     // 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.
104     RenderElement& rendererForRootBackground();
105
106     // Used only by Element::pseudoStyleCacheIsInvalid to get a first line style based off of a
107     // given new style, without accessing the cache.
108     PassRefPtr<RenderStyle> uncachedFirstLineStyle(RenderStyle*) const;
109
110     // Updates only the local style ptr of the object. Does not update the state of the object,
111     // and so only should be called when the style is known not to have changed (or from setStyle).
112     void setStyleInternal(PassRef<RenderStyle> style) { m_style = std::move(style); }
113
114     // Repaint only if our old bounds and new bounds are different. The caller may pass in newBounds and newOutlineBox if they are known.
115     bool repaintAfterLayoutIfNeeded(const RenderLayerModelObject* repaintContainer, const LayoutRect& oldBounds, const LayoutRect& oldOutlineBox, const LayoutRect* newBoundsPtr = nullptr, const LayoutRect* newOutlineBoxPtr = nullptr);
116
117     bool borderImageIsLoadedAndCanBeRendered() const;
118
119     // Returns true if this renderer requires a new stacking context.
120     bool createsGroup() const { return isTransparent() || hasMask() || hasFilter() || hasBlendMode(); }
121
122     bool isTransparent() const { return style().opacity() < 1.0f; }
123     float opacity() const { return style().opacity(); }
124
125     bool visibleToHitTesting() const { return style().visibility() == VISIBLE && style().pointerEvents() != PE_NONE; }
126
127     bool hasBackground() const { return style().hasBackground(); }
128     bool hasMask() const { return style().hasMask(); }
129     bool hasClip() const { return isOutOfFlowPositioned() && style().hasClip(); }
130     bool hasClipOrOverflowClip() const { return hasClip() || hasOverflowClip(); }
131     bool hasClipPath() const { return style().clipPath(); }
132     bool hasHiddenBackface() const { return style().backfaceVisibility() == BackfaceVisibilityHidden; }
133
134 #if ENABLE(CSS_FILTERS)
135     bool hasFilter() const { return style().hasFilter(); }
136 #else
137     bool hasFilter() const { return false; }
138 #endif
139
140 #if ENABLE(CSS_COMPOSITING)
141     bool hasBlendMode() const { return style().hasBlendMode(); }
142 #else
143     bool hasBlendMode() const { return false; }
144 #endif
145
146 #if ENABLE(CSS_SHAPES)
147     bool hasShapeOutside() const { return style().shapeOutside(); }
148 #else
149     bool hasShapeOutside() const { return false; }
150 #endif
151
152     bool repaintForPausedImageAnimationsIfNeeded(const IntRect& visibleRect);
153     bool hasPausedImageAnimations() const { return m_hasPausedImageAnimations; }
154     void setHasPausedImageAnimations(bool b) { m_hasPausedImageAnimations = b; }
155
156     RenderNamedFlowThread* renderNamedFlowThreadWrapper();
157
158     void setRenderBoxNeedsLazyRepaint(bool b) { m_renderBoxNeedsLazyRepaint = b; }
159     bool renderBoxNeedsLazyRepaint() const { return m_renderBoxNeedsLazyRepaint; }
160
161 protected:
162     enum BaseTypeFlags {
163         RenderLayerModelObjectFlag = 1 << 0,
164         RenderBoxModelObjectFlag = 1 << 1,
165         RenderInlineFlag = 1 << 2,
166         RenderReplacedFlag = 1 << 3,
167         RenderBlockFlag = 1 << 4,
168         RenderBlockFlowFlag = 1 << 5,
169     };
170
171     RenderElement(Element&, PassRef<RenderStyle>, unsigned baseTypeFlags);
172     RenderElement(Document&, PassRef<RenderStyle>, unsigned baseTypeFlags);
173
174     bool layerCreationAllowedForSubtree() const;
175
176     enum StylePropagationType { PropagateToAllChildren, PropagateToBlockChildrenOnly };
177     void propagateStyleToAnonymousChildren(StylePropagationType);
178
179     LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
180     LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
181
182     void setFirstChild(RenderObject* child) { m_firstChild = child; }
183     void setLastChild(RenderObject* child) { m_lastChild = child; }
184     void destroyLeftoverChildren();
185
186     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle);
187     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
188
189     virtual void insertedIntoTree() override;
190     virtual void willBeRemovedFromTree() override;
191     virtual void willBeDestroyed() override;
192
193     void setRenderInlineAlwaysCreatesLineBoxes(bool b) { m_renderInlineAlwaysCreatesLineBoxes = b; }
194     bool renderInlineAlwaysCreatesLineBoxes() const { return m_renderInlineAlwaysCreatesLineBoxes; }
195
196     static bool hasControlStatesForRenderer(const RenderObject*);
197     static ControlStates* controlStatesForRenderer(const RenderObject*);
198     static void removeControlStatesForRenderer(const RenderObject*);
199     static void addControlStatesForRenderer(const RenderObject*, ControlStates*);
200
201 private:
202     RenderElement(ContainerNode&, PassRef<RenderStyle>, unsigned baseTypeFlags);
203     void node() const = delete;
204     void nonPseudoNode() const = delete;
205     void generatingNode() const = delete;
206     void isText() const = delete;
207     void isRenderElement() const = delete;
208
209     virtual RenderObject* firstChildSlow() const override final { return firstChild(); }
210     virtual RenderObject* lastChildSlow() const override final { return lastChild(); }
211
212     bool shouldRepaintForStyleDifference(StyleDifference) const;
213     bool hasImmediateNonWhitespaceTextChildOrBorderOrOutline() const;
214
215     void updateFillImages(const FillLayer*, const FillLayer*);
216     void updateImage(StyleImage*, StyleImage*);
217 #if ENABLE(CSS_SHAPES)
218     void updateShapeImage(const ShapeValue*, const ShapeValue*);
219 #endif
220
221     StyleDifference adjustStyleDifference(StyleDifference, unsigned contextSensitiveProperties) const;
222     RenderStyle* cachedFirstLineStyle() const;
223
224     virtual void newImageAnimationFrameAvailable(CachedImage&) final override;
225
226     unsigned m_baseTypeFlags : 6;
227     bool m_ancestorLineBoxDirty : 1;
228     bool m_hasInitializedStyle : 1;
229
230     bool m_renderInlineAlwaysCreatesLineBoxes : 1;
231     bool m_renderBoxNeedsLazyRepaint : 1;
232     bool m_hasPausedImageAnimations : 1;
233
234     RenderObject* m_firstChild;
235     RenderObject* m_lastChild;
236
237     Ref<RenderStyle> m_style;
238
239     // FIXME: Get rid of this hack.
240     // Store state between styleWillChange and styleDidChange
241     static bool s_affectsParentBlock;
242     static bool s_noLongerAffectsParentBlock;
243 };
244
245 RENDER_OBJECT_TYPE_CASTS(RenderElement, isRenderElement())
246
247 inline RenderStyle& RenderElement::firstLineStyle() const
248 {
249     return document().styleSheetCollection().usesFirstLineRules() ? *cachedFirstLineStyle() : style();
250 }
251
252 inline void RenderElement::setAncestorLineBoxDirty(bool f)
253 {
254     m_ancestorLineBoxDirty = f;
255     if (m_ancestorLineBoxDirty)
256         setNeedsLayout();
257 }
258
259 inline void RenderElement::setChildNeedsLayout(MarkingBehavior markParents)
260 {
261     ASSERT(!isSetNeedsLayoutForbidden());
262     if (normalChildNeedsLayout())
263         return;
264     setNormalChildNeedsLayoutBit(true);
265     if (markParents == MarkContainingBlockChain)
266         markContainingBlocksForLayout();
267 }
268
269 inline LayoutUnit RenderElement::valueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
270 {
271     return WebCore::valueForLength(length, maximumValue, &view(), roundPercentages);
272 }
273
274 inline LayoutUnit RenderElement::minimumValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
275 {
276     return WebCore::minimumValueForLength(length, maximumValue, &view(), roundPercentages);
277 }
278
279 inline bool RenderElement::isRenderLayerModelObject() const
280 {
281     return m_baseTypeFlags & RenderLayerModelObjectFlag;
282 }
283
284 inline bool RenderElement::isBoxModelObject() const
285 {
286     return m_baseTypeFlags & RenderBoxModelObjectFlag;
287 }
288
289 inline bool RenderElement::isRenderBlock() const
290 {
291     return m_baseTypeFlags & RenderBlockFlag;
292 }
293
294 inline bool RenderElement::isRenderBlockFlow() const
295 {
296     return m_baseTypeFlags & RenderBlockFlowFlag;
297 }
298
299 inline bool RenderElement::isRenderReplaced() const
300 {
301     return m_baseTypeFlags & RenderReplacedFlag;
302 }
303
304 inline bool RenderElement::isRenderInline() const
305 {
306     return m_baseTypeFlags & RenderInlineFlag;
307 }
308
309 inline Element* RenderElement::generatingElement() const
310 {
311     if (parent() && isRenderNamedFlowFragment())
312         return parent()->generatingElement();
313     return toElement(RenderObject::generatingNode());
314 }
315
316 inline bool RenderObject::isRenderLayerModelObject() const
317 {
318     return isRenderElement() && toRenderElement(this)->isRenderLayerModelObject();
319 }
320
321 inline bool RenderObject::isBoxModelObject() const
322 {
323     return isRenderElement() && toRenderElement(this)->isBoxModelObject();
324 }
325
326 inline bool RenderObject::isRenderBlock() const
327 {
328     return isRenderElement() && toRenderElement(this)->isRenderBlock();
329 }
330
331 inline bool RenderObject::isRenderBlockFlow() const
332 {
333     return isRenderElement() && toRenderElement(this)->isRenderBlockFlow();
334 }
335
336 inline bool RenderObject::isRenderReplaced() const
337 {
338     return isRenderElement() && toRenderElement(this)->isRenderReplaced();
339 }
340
341 inline bool RenderObject::isRenderInline() const
342 {
343     return isRenderElement() && toRenderElement(this)->isRenderInline();
344 }
345
346 inline RenderStyle& RenderObject::style() const
347 {
348     if (isText())
349         return m_parent->style();
350     return toRenderElement(this)->style();
351 }
352
353 inline RenderStyle& RenderObject::firstLineStyle() const
354 {
355     if (isText())
356         return m_parent->firstLineStyle();
357     return toRenderElement(this)->firstLineStyle();
358 }
359
360 inline RenderElement* ContainerNode::renderer() const
361 {
362     return toRenderElement(Node::renderer());
363 }
364
365 inline int adjustForAbsoluteZoom(int value, const RenderElement& renderer)
366 {
367     return adjustForAbsoluteZoom(value, renderer.style());
368 }
369
370 #if ENABLE(SUBPIXEL_LAYOUT)
371 inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const RenderElement& renderer)
372 {
373     return adjustLayoutUnitForAbsoluteZoom(value, renderer.style());
374 }
375 #endif
376
377 } // namespace WebCore
378
379 #endif // RenderElement_h