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