Move setPseudoStyle() to RenderImage (from 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 RenderElement* createFor(Element&, RenderStyle&);
35
36     RenderStyle* style() const { return m_style.get(); }
37     RenderStyle* firstLineStyle() const;
38
39     virtual void setStyle(PassRefPtr<RenderStyle>);
40     // Called to update a style that is allowed to trigger animations.
41     void setAnimatableStyle(PassRefPtr<RenderStyle>);
42
43     // This is null for anonymous renderers.
44     Element* element() const { return toElement(RenderObject::node()); }
45     Element* nonPseudoElement() const { return toElement(RenderObject::nonPseudoNode()); }
46     Element* generatingElement() const { return toElement(RenderObject::generatingNode()); }
47
48     RenderObject* firstChild() const { return m_firstChild; }
49     RenderObject* lastChild() const { return m_lastChild; }
50
51     // FIXME: Make these standalone and move to relevant files.
52     bool isRenderLayerModelObject() const;
53     bool isBoxModelObject() const;
54     bool isRenderBlock() const;
55     bool isRenderBlockFlow() const;
56     bool isRenderReplaced() const;
57     bool isRenderInline() const;
58
59     virtual bool isChildAllowed(RenderObject*, RenderStyle*) const { return true; }
60     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
61     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0) { return addChild(newChild, beforeChild); }
62     virtual void removeChild(RenderObject*);
63
64     // The following functions are used when the render tree hierarchy changes to make sure layers get
65     // properly added and removed. Since containership can be implemented by any subclass, and since a hierarchy
66     // can contain a mixture of boxes and other object types, these functions need to be in the base class.
67     void addLayers(RenderLayer* parentLayer);
68     void removeLayers(RenderLayer* parentLayer);
69     void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);
70     RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, bool checkParent = true);
71
72     enum NotifyChildrenType { NotifyChildren, DontNotifyChildren };
73     void insertChildInternal(RenderObject*, RenderObject* beforeChild, NotifyChildrenType);
74     void removeChildInternal(RenderObject*, NotifyChildrenType);
75
76     virtual RenderElement* hoverAncestor() const;
77
78     virtual void dirtyLinesFromChangedChild(RenderObject*) { }
79
80     bool ancestorLineBoxDirty() const { return m_ancestorLineBoxDirty; }
81     void setAncestorLineBoxDirty(bool f = true);
82
83     void setChildNeedsLayout(MarkingBehavior = MarkContainingBlockChain);
84     void clearChildNeedsLayout();
85     void setNeedsPositionedMovementLayout(const RenderStyle* oldStyle);
86     void setNeedsSimplifiedNormalFlowLayout();
87
88     virtual void paint(PaintInfo&, const LayoutPoint&) = 0;
89
90     // Recursive function that computes the size and position of this object and all its descendants.
91     virtual void layout();
92
93     /* This function performs a layout only if one is needed. */
94     void layoutIfNeeded() { if (needsLayout()) layout(); }
95
96     // 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.
97     RenderElement* rendererForRootBackground();
98
99     // Used only by Element::pseudoStyleCacheIsInvalid to get a first line style based off of a
100     // given new style, without accessing the cache.
101     PassRefPtr<RenderStyle> uncachedFirstLineStyle(RenderStyle*) const;
102
103     // Updates only the local style ptr of the object. Does not update the state of the object,
104     // and so only should be called when the style is known not to have changed (or from setStyle).
105     void setStyleInternal(PassRefPtr<RenderStyle> style) { m_style = style; }
106
107 protected:
108     enum BaseTypeFlags {
109         RenderLayerModelObjectFlag = 1 << 0,
110         RenderBoxModelObjectFlag = 1 << 1,
111         RenderInlineFlag = 1 << 2,
112         RenderReplacedFlag = 1 << 3,
113         RenderBlockFlag = 1 << 4,
114         RenderBlockFlowFlag = 1 << 5,
115     };
116
117     explicit RenderElement(Element*, unsigned baseTypeFlags);
118
119     bool layerCreationAllowedForSubtree() const;
120
121     enum StylePropagationType { PropagateToAllChildren, PropagateToBlockChildrenOnly };
122     void propagateStyleToAnonymousChildren(StylePropagationType);
123
124     LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
125     LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
126
127     void setFirstChild(RenderObject* child) { m_firstChild = child; }
128     void setLastChild(RenderObject* child) { m_lastChild = child; }
129     void destroyLeftoverChildren();
130
131     virtual void styleWillChange(StyleDifference, const RenderStyle*);
132     virtual void styleDidChange(StyleDifference, const RenderStyle*);
133
134     virtual void insertedIntoTree() OVERRIDE;
135     virtual void willBeRemovedFromTree() OVERRIDE;
136     virtual void willBeDestroyed() OVERRIDE;
137
138 private:
139     void node() const WTF_DELETED_FUNCTION;
140     void nonPseudoNode() const WTF_DELETED_FUNCTION;
141     void generatingNode() const WTF_DELETED_FUNCTION;
142     void isText() const WTF_DELETED_FUNCTION;
143     void isRenderElement() const WTF_DELETED_FUNCTION;
144
145     virtual RenderObject* firstChildSlow() const OVERRIDE FINAL { return firstChild(); }
146     virtual RenderObject* lastChildSlow() const OVERRIDE FINAL { return lastChild(); }
147
148     bool shouldRepaintForStyleDifference(StyleDifference) const;
149     bool hasImmediateNonWhitespaceTextChildOrBorderOrOutline() const;
150
151     void updateFillImages(const FillLayer*, const FillLayer*);
152     void updateImage(StyleImage*, StyleImage*);
153 #if ENABLE(CSS_SHAPES)
154     void updateShapeImage(const ShapeValue*, const ShapeValue*);
155 #endif
156
157     StyleDifference adjustStyleDifference(StyleDifference, unsigned contextSensitiveProperties) const;
158     RenderStyle* cachedFirstLineStyle() const;
159
160     unsigned m_baseTypeFlags : 6;
161     bool m_ancestorLineBoxDirty : 1;
162
163     RenderObject* m_firstChild;
164     RenderObject* m_lastChild;
165
166     RefPtr<RenderStyle> m_style;
167
168     // FIXME: Get rid of this hack.
169     // Store state between styleWillChange and styleDidChange
170     static bool s_affectsParentBlock;
171     static bool s_noLongerAffectsParentBlock;
172 };
173
174 inline RenderStyle* RenderElement::firstLineStyle() const
175 {
176     return document().styleSheetCollection().usesFirstLineRules() ? cachedFirstLineStyle() : style();
177 }
178
179 inline void RenderElement::setAncestorLineBoxDirty(bool f)
180 {
181     m_ancestorLineBoxDirty = f;
182     if (m_ancestorLineBoxDirty)
183         setNeedsLayout();
184 }
185
186 inline void RenderElement::setChildNeedsLayout(MarkingBehavior markParents)
187 {
188     ASSERT(!isSetNeedsLayoutForbidden());
189     if (normalChildNeedsLayout())
190         return;
191     setNormalChildNeedsLayoutBit(true);
192     if (markParents == MarkContainingBlockChain)
193         markContainingBlocksForLayout();
194 }
195
196 inline LayoutUnit RenderElement::valueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
197 {
198     return WebCore::valueForLength(length, maximumValue, &view(), roundPercentages);
199 }
200
201 inline LayoutUnit RenderElement::minimumValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
202 {
203     return WebCore::minimumValueForLength(length, maximumValue, &view(), roundPercentages);
204 }
205
206 inline bool RenderElement::isRenderLayerModelObject() const
207 {
208     return m_baseTypeFlags & RenderLayerModelObjectFlag;
209 }
210
211 inline bool RenderElement::isBoxModelObject() const
212 {
213     return m_baseTypeFlags & RenderBoxModelObjectFlag;
214 }
215
216 inline bool RenderElement::isRenderBlock() const
217 {
218     return m_baseTypeFlags & RenderBlockFlag;
219 }
220
221 inline bool RenderElement::isRenderBlockFlow() const
222 {
223     return m_baseTypeFlags & RenderBlockFlowFlag;
224 }
225
226 inline bool RenderElement::isRenderReplaced() const
227 {
228     return m_baseTypeFlags & RenderReplacedFlag;
229 }
230
231 inline bool RenderElement::isRenderInline() const
232 {
233     return m_baseTypeFlags & RenderInlineFlag;
234 }
235
236 inline RenderElement& toRenderElement(RenderObject& object)
237 {
238     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderElement());
239     return static_cast<RenderElement&>(object);
240 }
241
242 inline const RenderElement& toRenderElement(const RenderObject& object)
243 {
244     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderElement());
245     return static_cast<const RenderElement&>(object);
246 }
247
248 inline RenderElement* toRenderElement(RenderObject* object)
249 {
250     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderElement());
251     return static_cast<RenderElement*>(object);
252 }
253
254 inline const RenderElement* toRenderElement(const RenderObject* object)
255 {
256     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderElement());
257     return static_cast<const RenderElement*>(object);
258 }
259
260 // This will catch anyone doing an unnecessary cast.
261 void toRenderElement(const RenderElement*);
262 void toRenderElement(const RenderElement&);
263
264 inline bool RenderObject::isRenderLayerModelObject() const
265 {
266     return isRenderElement() && toRenderElement(this)->isRenderLayerModelObject();
267 }
268
269 inline bool RenderObject::isBoxModelObject() const
270 {
271     return isRenderElement() && toRenderElement(this)->isBoxModelObject();
272 }
273
274 inline bool RenderObject::isRenderBlock() const
275 {
276     return isRenderElement() && toRenderElement(this)->isRenderBlock();
277 }
278
279 inline bool RenderObject::isRenderBlockFlow() const
280 {
281     return isRenderElement() && toRenderElement(this)->isRenderBlockFlow();
282 }
283
284 inline bool RenderObject::isRenderReplaced() const
285 {
286     return isRenderElement() && toRenderElement(this)->isRenderReplaced();
287 }
288
289 inline bool RenderObject::isRenderInline() const
290 {
291     return isRenderElement() && toRenderElement(this)->isRenderInline();
292 }
293
294 inline RenderStyle* RenderObject::style() const
295 {
296     if (isText())
297         return m_parent->style();
298     return toRenderElement(this)->style();
299 }
300
301 inline RenderStyle* RenderObject::firstLineStyle() const
302 {
303     if (isText())
304         return m_parent->firstLineStyle();
305     return toRenderElement(this)->firstLineStyle();
306 }
307
308 inline RenderElement* ContainerNode::renderer() const
309 {
310     return toRenderElement(Node::renderer());
311 }
312
313 } // namespace WebCore
314
315 #endif // RenderElement_h