Native text selection UI is incorrectly suppressed in Microsoft Visio
[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 #pragma once
24
25 #include "LengthFunctions.h"
26 #include "RenderObject.h"
27
28 namespace WebCore {
29
30 class ControlStates;
31 class RenderBlock;
32 class RenderTreeBuilder;
33
34 class RenderElement : public RenderObject {
35     WTF_MAKE_ISO_ALLOCATED(RenderElement);
36 public:
37     virtual ~RenderElement();
38
39     enum RendererCreationType { CreateAllRenderers, OnlyCreateBlockAndFlexboxRenderers };
40     static RenderPtr<RenderElement> createFor(Element&, RenderStyle&&, RendererCreationType = CreateAllRenderers);
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 > StyleDifference::Equal 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 = StyleDifference::Equal);
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     std::unique_ptr<RenderStyle> getUncachedPseudoStyle(const PseudoStyleRequest&, const RenderStyle* parentStyle = nullptr, const RenderStyle* ownStyle = nullptr) const;
61
62     // This is null for anonymous renderers.
63     Element* element() const { return downcast<Element>(RenderObject::node()); }
64     Element* nonPseudoElement() const { return downcast<Element>(RenderObject::nonPseudoNode()); }
65     Element* generatingElement() const;
66
67     RenderObject* firstChild() const { return m_firstChild; }
68     RenderObject* lastChild() const { return m_lastChild; }
69
70     bool canContainFixedPositionObjects() const;
71     bool canContainAbsolutelyPositionedObjects() const;
72
73     Color selectionColor(CSSPropertyID) const;
74     std::unique_ptr<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
89     virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const { return true; }
90     void didAttachChild(RenderObject& child, RenderObject* beforeChild);
91
92     // The following functions are used when the render tree hierarchy changes to make sure layers get
93     // properly added and removed. Since containership can be implemented by any subclass, and since a hierarchy
94     // can contain a mixture of boxes and other object types, these functions need to be in the base class.
95     void addLayers(RenderLayer* parentLayer);
96     void removeLayers(RenderLayer* parentLayer);
97     void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);
98     RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, bool checkParent = true);
99
100     virtual void dirtyLinesFromChangedChild(RenderObject&) { }
101
102     bool ancestorLineBoxDirty() const { return m_ancestorLineBoxDirty; }
103     void setAncestorLineBoxDirty(bool f = true);
104
105     void setChildNeedsLayout(MarkingBehavior = MarkContainingBlockChain);
106     void clearChildNeedsLayout();
107     void setNeedsPositionedMovementLayout(const RenderStyle* oldStyle);
108     void setNeedsSimplifiedNormalFlowLayout();
109
110     virtual void paint(PaintInfo&, const LayoutPoint&) = 0;
111
112     // inline-block elements paint all phases atomically. This function ensures that. Certain other elements
113     // (grid items, flex items) require this behavior as well, and this function exists as a helper for them.
114     // It is expected that the caller will call this function independent of the value of paintInfo.phase.
115     void paintAsInlineBlock(PaintInfo&, const LayoutPoint&);
116
117     // Recursive function that computes the size and position of this object and all its descendants.
118     virtual void layout();
119
120     /* This function performs a layout only if one is needed. */
121     void layoutIfNeeded() { if (needsLayout()) layout(); }
122
123     // Updates only the local style ptr of the object. Does not update the state of the object,
124     // and so only should be called when the style is known not to have changed (or from setStyle).
125     void setStyleInternal(RenderStyle&& style) { m_style = WTFMove(style); }
126
127     // Repaint only if our old bounds and new bounds are different. The caller may pass in newBounds and newOutlineBox if they are known.
128     bool repaintAfterLayoutIfNeeded(const RenderLayerModelObject* repaintContainer, const LayoutRect& oldBounds, const LayoutRect& oldOutlineBox, const LayoutRect* newBoundsPtr = nullptr, const LayoutRect* newOutlineBoxPtr = nullptr);
129
130     bool borderImageIsLoadedAndCanBeRendered() const;
131     bool mayCauseRepaintInsideViewport(const IntRect* visibleRect = nullptr) const;
132     bool isVisibleInDocumentRect(const IntRect& documentRect) const;
133
134     // Returns true if this renderer requires a new stacking context.
135     static bool createsGroupForStyle(const RenderStyle&);
136     bool createsGroup() const { return createsGroupForStyle(style()); }
137
138     bool isTransparent() const { return style().opacity() < 1.0f; }
139     float opacity() const { return style().opacity(); }
140
141     bool visibleToHitTesting() const { return style().visibility() == Visibility::Visible && style().pointerEvents() != PointerEvents::None; }
142
143     bool hasBackground() const { return style().hasBackground(); }
144     bool hasMask() const { return style().hasMask(); }
145     bool hasClip() const { return isOutOfFlowPositioned() && style().hasClip(); }
146     bool hasClipOrOverflowClip() const { return hasClip() || hasOverflowClip(); }
147     bool hasClipPath() const { return style().clipPath(); }
148     bool hasHiddenBackface() const { return style().backfaceVisibility() == BackfaceVisibility::Hidden; }
149     bool hasOutlineAnnotation() const;
150     bool hasOutline() const { return style().hasOutline() || hasOutlineAnnotation(); }
151     bool hasSelfPaintingLayer() const;
152
153     bool checkForRepaintDuringLayout() const;
154
155     // anchorRect() is conceptually similar to absoluteBoundingBoxRect(), but is intended for scrolling to an anchor.
156     // For inline renderers, this gets the logical top left of the first leaf child and the logical bottom right of the
157     // last leaf child, converts them to absolute coordinates, and makes a box out of them.
158     LayoutRect absoluteAnchorRect(bool* insideFixed = nullptr) const;
159
160     bool hasFilter() const { return style().hasFilter(); }
161     bool hasBackdropFilter() const
162     {
163 #if ENABLE(FILTERS_LEVEL_2)
164         return style().hasBackdropFilter();
165 #else
166         return false;
167 #endif
168     }
169
170
171 #if ENABLE(CSS_COMPOSITING)
172     bool hasBlendMode() const { return style().hasBlendMode(); }
173 #else
174     bool hasBlendMode() const { return false; }
175 #endif
176
177     bool hasShapeOutside() const { return style().shapeOutside(); }
178
179     void registerForVisibleInViewportCallback();
180     void unregisterForVisibleInViewportCallback();
181
182     VisibleInViewportState visibleInViewportState() const { return static_cast<VisibleInViewportState>(m_visibleInViewportState); }
183     void setVisibleInViewportState(VisibleInViewportState);
184     virtual void visibleInViewportStateChanged();
185
186     bool repaintForPausedImageAnimationsIfNeeded(const IntRect& visibleRect, CachedImage&);
187     bool hasPausedImageAnimations() const { return m_hasPausedImageAnimations; }
188     void setHasPausedImageAnimations(bool b) { m_hasPausedImageAnimations = b; }
189
190     void setRenderBoxNeedsLazyRepaint(bool b) { m_renderBoxNeedsLazyRepaint = b; }
191     bool renderBoxNeedsLazyRepaint() const { return m_renderBoxNeedsLazyRepaint; }
192
193     bool hasCounterNodeMap() const { return m_hasCounterNodeMap; }
194     void setHasCounterNodeMap(bool f) { m_hasCounterNodeMap = f; }
195
196     const RenderElement* enclosingRendererWithTextDecoration(OptionSet<TextDecoration>, bool firstLine) const;
197     void drawLineForBoxSide(GraphicsContext&, const FloatRect&, BoxSide, Color, BorderStyle, float adjacentWidth1, float adjacentWidth2, bool antialias = false) const;
198
199 #if ENABLE(TEXT_AUTOSIZING)
200     void adjustComputedFontSizesOnBlocks(float size, float visibleWidth);
201     WEBCORE_EXPORT void resetTextAutosizing();
202 #endif
203     RenderBlock* containingBlockForFixedPosition() const;
204     RenderBlock* containingBlockForAbsolutePosition() const;
205
206     RespectImageOrientationEnum shouldRespectImageOrientation() const;
207
208     void removeFromRenderFragmentedFlow();
209     virtual void resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(RenderFragmentedFlow*);
210
211     // Called before anonymousChild.setStyle(). Override to set custom styles for
212     // the child.
213     virtual void updateAnonymousChildStyle(RenderStyle&) const { };
214
215     bool hasContinuationChainNode() const { return m_hasContinuationChainNode; }
216     bool isContinuation() const { return m_isContinuation; }
217     void setIsContinuation() { m_isContinuation = true; }
218     bool isFirstLetter() const { return m_isFirstLetter; }
219     void setIsFirstLetter() { m_isFirstLetter = true; }
220
221     RenderObject* attachRendererInternal(RenderPtr<RenderObject> child, RenderObject* beforeChild);
222     RenderPtr<RenderObject> detachRendererInternal(RenderObject&);
223
224 protected:
225     enum BaseTypeFlag {
226         RenderLayerModelObjectFlag  = 1 << 0,
227         RenderBoxModelObjectFlag    = 1 << 1,
228         RenderInlineFlag            = 1 << 2,
229         RenderReplacedFlag          = 1 << 3,
230         RenderBlockFlag             = 1 << 4,
231         RenderBlockFlowFlag         = 1 << 5,
232     };
233     
234     typedef unsigned BaseTypeFlags;
235
236     RenderElement(Element&, RenderStyle&&, BaseTypeFlags);
237     RenderElement(Document&, RenderStyle&&, BaseTypeFlags);
238
239     bool layerCreationAllowedForSubtree() const;
240
241     enum StylePropagationType { PropagateToAllChildren, PropagateToBlockChildrenOnly };
242     void propagateStyleToAnonymousChildren(StylePropagationType);
243
244     LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue) const;
245     LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue) const;
246
247     void setFirstChild(RenderObject* child) { m_firstChild = child; }
248     void setLastChild(RenderObject* child) { m_lastChild = child; }
249
250     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle);
251     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
252
253     void insertedIntoTree() override;
254     void willBeRemovedFromTree() override;
255     void willBeDestroyed() override;
256
257     void setRenderInlineAlwaysCreatesLineBoxes(bool b) { m_renderInlineAlwaysCreatesLineBoxes = b; }
258     bool renderInlineAlwaysCreatesLineBoxes() const { return m_renderInlineAlwaysCreatesLineBoxes; }
259
260     void setHasContinuationChainNode(bool b) { m_hasContinuationChainNode = b; }
261
262     void setRenderBlockHasMarginBeforeQuirk(bool b) { m_renderBlockHasMarginBeforeQuirk = b; }
263     void setRenderBlockHasMarginAfterQuirk(bool b) { m_renderBlockHasMarginAfterQuirk = b; }
264     void setRenderBlockShouldForceRelayoutChildren(bool b) { m_renderBlockShouldForceRelayoutChildren = b; }
265     bool renderBlockHasMarginBeforeQuirk() const { return m_renderBlockHasMarginBeforeQuirk; }
266     bool renderBlockHasMarginAfterQuirk() const { return m_renderBlockHasMarginAfterQuirk; }
267     bool renderBlockShouldForceRelayoutChildren() const { return m_renderBlockShouldForceRelayoutChildren; }
268
269     void setRenderBlockFlowLineLayoutPath(unsigned u) { m_renderBlockFlowLineLayoutPath = u; }
270     void setRenderBlockFlowHasMarkupTruncation(bool b) { m_renderBlockFlowHasMarkupTruncation = b; }
271     unsigned renderBlockFlowLineLayoutPath() const { return m_renderBlockFlowLineLayoutPath; }
272     bool renderBlockFlowHasMarkupTruncation() const { return m_renderBlockFlowHasMarkupTruncation; }
273
274     void paintFocusRing(PaintInfo&, const RenderStyle&, const Vector<LayoutRect>& focusRingRects);
275     void paintOutline(PaintInfo&, const LayoutRect&);
276     void updateOutlineAutoAncestor(bool hasOutlineAuto);
277
278     void removeFromRenderFragmentedFlowIncludingDescendants(bool shouldUpdateState);
279     void adjustFragmentedFlowStateOnContainingBlockChangeIfNeeded();
280     
281     bool isVisibleInViewport() const;
282
283 private:
284     RenderElement(ContainerNode&, RenderStyle&&, BaseTypeFlags);
285     void node() const = delete;
286     void nonPseudoNode() const = delete;
287     void generatingNode() const = delete;
288     void isText() const = delete;
289     void isRenderElement() const = delete;
290
291     RenderObject* firstChildSlow() const final { return firstChild(); }
292     RenderObject* lastChildSlow() const final { return lastChild(); }
293
294     // Called when an object that was floating or positioned becomes a normal flow object
295     // again.  We have to make sure the render tree updates as needed to accommodate the new
296     // normal flow object.
297     void handleDynamicFloatPositionChange();
298
299     bool shouldRepaintForStyleDifference(StyleDifference) const;
300     bool hasImmediateNonWhitespaceTextChildOrBorderOrOutline() const;
301
302     void updateFillImages(const FillLayer*, const FillLayer&);
303     void updateImage(StyleImage*, StyleImage*);
304     void updateShapeImage(const ShapeValue*, const ShapeValue*);
305
306     StyleDifference adjustStyleDifference(StyleDifference, OptionSet<StyleDifferenceContextSensitiveProperty>) const;
307     std::unique_ptr<RenderStyle> computeFirstLineStyle() const;
308     void invalidateCachedFirstLineStyle();
309
310     bool canDestroyDecodedData() final { return !isVisibleInViewport(); }
311     VisibleInViewportState imageFrameAvailable(CachedImage&, ImageAnimatingState, const IntRect* changeRect) final;
312     void didRemoveCachedImageClient(CachedImage&) final;
313
314     bool getLeadingCorner(FloatPoint& output, bool& insideFixed) const;
315     bool getTrailingCorner(FloatPoint& output, bool& insideFixed) const;
316
317     void clearSubtreeLayoutRootIfNeeded() const;
318     
319     bool shouldWillChangeCreateStackingContext() const;
320     void issueRepaintForOutlineAuto(float outlineSize);
321
322     unsigned m_baseTypeFlags : 6;
323     unsigned m_ancestorLineBoxDirty : 1;
324     unsigned m_hasInitializedStyle : 1;
325
326     unsigned m_renderInlineAlwaysCreatesLineBoxes : 1;
327     unsigned m_renderBoxNeedsLazyRepaint : 1;
328     unsigned m_hasPausedImageAnimations : 1;
329     unsigned m_hasCounterNodeMap : 1;
330     unsigned m_hasContinuationChainNode : 1;
331     unsigned m_isContinuation : 1;
332     unsigned m_isFirstLetter : 1;
333     mutable unsigned m_hasValidCachedFirstLineStyle : 1;
334
335     unsigned m_renderBlockHasMarginBeforeQuirk : 1;
336     unsigned m_renderBlockHasMarginAfterQuirk : 1;
337     unsigned m_renderBlockShouldForceRelayoutChildren : 1;
338     unsigned m_renderBlockFlowHasMarkupTruncation : 1;
339     unsigned m_renderBlockFlowLineLayoutPath : 2;
340
341     unsigned m_isRegisteredForVisibleInViewportCallback : 1;
342     unsigned m_visibleInViewportState : 2;
343
344     RenderObject* m_firstChild;
345     RenderObject* m_lastChild;
346
347     RenderStyle m_style;
348 };
349
350 inline void RenderElement::setAncestorLineBoxDirty(bool f)
351 {
352     m_ancestorLineBoxDirty = f;
353     if (m_ancestorLineBoxDirty)
354         setNeedsLayout();
355 }
356
357 inline void RenderElement::setChildNeedsLayout(MarkingBehavior markParents)
358 {
359     ASSERT(!isSetNeedsLayoutForbidden());
360     if (normalChildNeedsLayout())
361         return;
362     setNormalChildNeedsLayoutBit(true);
363     if (markParents == MarkContainingBlockChain)
364         markContainingBlocksForLayout();
365 }
366
367 inline LayoutUnit RenderElement::valueForLength(const Length& length, LayoutUnit maximumValue) const
368 {
369     return WebCore::valueForLength(length, maximumValue);
370 }
371
372 inline LayoutUnit RenderElement::minimumValueForLength(const Length& length, LayoutUnit maximumValue) const
373 {
374     return WebCore::minimumValueForLength(length, maximumValue);
375 }
376
377 inline bool RenderElement::isRenderLayerModelObject() const
378 {
379     return m_baseTypeFlags & RenderLayerModelObjectFlag;
380 }
381
382 inline bool RenderElement::isBoxModelObject() const
383 {
384     return m_baseTypeFlags & RenderBoxModelObjectFlag;
385 }
386
387 inline bool RenderElement::isRenderBlock() const
388 {
389     return m_baseTypeFlags & RenderBlockFlag;
390 }
391
392 inline bool RenderElement::isRenderBlockFlow() const
393 {
394     return m_baseTypeFlags & RenderBlockFlowFlag;
395 }
396
397 inline bool RenderElement::isRenderReplaced() const
398 {
399     return m_baseTypeFlags & RenderReplacedFlag;
400 }
401
402 inline bool RenderElement::isRenderInline() const
403 {
404     return m_baseTypeFlags & RenderInlineFlag;
405 }
406
407 inline Element* RenderElement::generatingElement() const
408 {
409     return downcast<Element>(RenderObject::generatingNode());
410 }
411
412 inline bool RenderElement::canContainFixedPositionObjects() const
413 {
414     return isRenderView()
415         || (hasTransform() && isRenderBlock())
416         || isSVGForeignObject()
417         || isOutOfFlowRenderFragmentedFlow();
418 }
419
420 inline bool RenderElement::canContainAbsolutelyPositionedObjects() const
421 {
422     return style().position() != PositionType::Static
423         || (isRenderBlock() && hasTransformRelatedProperty())
424         || isSVGForeignObject()
425         || isRenderView();
426 }
427
428 inline bool RenderElement::createsGroupForStyle(const RenderStyle& style)
429 {
430     return style.opacity() < 1.0f || style.hasMask() || style.clipPath() || style.hasFilter() || style.hasBackdropFilter() || style.hasBlendMode();
431 }
432
433 inline bool RenderObject::isRenderLayerModelObject() const
434 {
435     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderLayerModelObject();
436 }
437
438 inline bool RenderObject::isBoxModelObject() const
439 {
440     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isBoxModelObject();
441 }
442
443 inline bool RenderObject::isRenderBlock() const
444 {
445     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderBlock();
446 }
447
448 inline bool RenderObject::isRenderBlockFlow() const
449 {
450     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderBlockFlow();
451 }
452
453 inline bool RenderObject::isRenderReplaced() const
454 {
455     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderReplaced();
456 }
457
458 inline bool RenderObject::isRenderInline() const
459 {
460     return is<RenderElement>(*this) && downcast<RenderElement>(*this).isRenderInline();
461 }
462
463 inline const RenderStyle& RenderObject::style() const
464 {
465     if (isText())
466         return m_parent->style();
467     return downcast<RenderElement>(*this).style();
468 }
469
470 inline const RenderStyle& RenderObject::firstLineStyle() const
471 {
472     if (isText())
473         return m_parent->firstLineStyle();
474     return downcast<RenderElement>(*this).firstLineStyle();
475 }
476
477 inline RenderElement* ContainerNode::renderer() const
478 {
479     return downcast<RenderElement>(Node::renderer());
480 }
481
482 inline int adjustForAbsoluteZoom(int value, const RenderElement& renderer)
483 {
484     return adjustForAbsoluteZoom(value, renderer.style());
485 }
486
487 inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const RenderElement& renderer)
488 {
489     return adjustLayoutUnitForAbsoluteZoom(value, renderer.style());
490 }
491
492 } // namespace WebCore
493
494 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderElement, isRenderElement())