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