1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef LAYOUT_SVG_ISVGDISPLAYABLEFRAME_H_
#define LAYOUT_SVG_ISVGDISPLAYABLEFRAME_H_
#include "gfxMatrix.h"
#include "gfxPoint.h"
#include "gfxRect.h"
#include "nsQueryFrame.h"
#include "nsRect.h"
#include "mozilla/gfx/MatrixFwd.h"
class gfxContext;
class nsIFrame;
namespace mozilla {
class SVGAnimatedLengthList;
class SVGAnimatedNumberList;
class SVGBBox;
class SVGLengthList;
class SVGNumberList;
class SVGUserUnitList;
namespace image {
struct imgDrawingParams;
} // namespace image
/**
* This class is used for elements that can be part of a directly displayable
* section of a document. This includes SVGGeometryFrame and SVGGFrame.
* (Even though the latter doesn't display anything itself, if it contains
* SVGGeometryFrame descendants it is can still be part of a displayable
* section of a document) This class is not used for elements that can never
* display directly, including SVGGradientFrame and SVGPatternFrame. (The
* latter may contain displayable content, but it and its content are never
* *directly* displayed in a document. It can only end up being displayed by
* means of a reference from other content.)
*
* Note specifically that SVG frames that inherit SVGContainerFrame do *not*
* implement this class (only those that inherit SVGDisplayContainerFrame
* do.)
*/
class ISVGDisplayableFrame : public nsQueryFrame {
public:
using imgDrawingParams = image::imgDrawingParams;
NS_DECL_QUERYFRAME_TARGET(ISVGDisplayableFrame)
/**
* Paint this frame.
*
* SVG is painted using a combination of display lists (trees of
* nsDisplayItem built by BuildDisplayList() implementations) and recursive
* PaintSVG calls. SVG frames with the NS_FRAME_IS_NONDISPLAY bit set are
* always painted using recursive PaintSVG calls since display list painting
* would provide no advantages (they wouldn't be retained for invalidation).
* Displayed SVG is normally painted via a display list tree created under
* SVGOuterSVGFrame::BuildDisplayList, unless the
* svg.display-lists.painting.enabled pref has been set to false by the user
* in which case it is done via an SVGOuterSVGFrame::PaintSVG() call that
* recurses over the entire SVG frame tree. In future we may use PaintSVG()
* calls on SVG container frames to avoid display list construction when it
* is expensive and unnecessary (see bug 934411).
*
* @param aTransform The transform that has to be multiplied onto the
* DrawTarget in order for drawing to be in this frame's SVG user space.
* Implementations of this method should avoid multiplying aTransform onto
* the DrawTarget when possible and instead just pass a transform down to
* their children. This is preferable because changing the transform is
* very expensive for certain DrawTarget backends so it is best to minimize
* the number of transform changes.
*
* @param aImgParams imagelib parameters that may be used when painting
* feImage.
*
* @param aDirtyRect The area being redrawn, in frame offset pixel
* coordinates.
*/
virtual void PaintSVG(gfxContext& aContext, const gfxMatrix& aTransform,
imgDrawingParams& aImgParams,
const nsIntRect* aDirtyRect = nullptr) = 0;
/**
* Returns the frame that should handle pointer events at aPoint. aPoint is
* expected to be in the SVG user space of the frame on which this method is
* called. The frame returned may be the frame on which this method is
* called, any of its descendants or else nullptr.
*/
virtual nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) = 0;
// Called on SVG child frames (except NS_FRAME_IS_NONDISPLAY frames)
// to update and then invalidate their cached bounds. This method is not
// called until after the SVGOuterSVGFrame has had its initial reflow
// (i.e. once the SVG viewport dimensions are known). It should also only
// be called by SVGOuterSVGFrame during its reflow.
virtual void ReflowSVG() = 0;
// Flags to pass to NotifySVGChange:
//
// TRANSFORM_CHANGED:
// the current transform matrix for this frame has changed
// COORD_CONTEXT_CHANGED:
// the dimensions of this frame's coordinate context has changed (percentage
// lengths must be reevaluated)
// FULL_ZOOM_CHANGED:
// the page's zoom level has changed
enum SVGChangedFlags {
TRANSFORM_CHANGED = 0x01,
COORD_CONTEXT_CHANGED = 0x02,
FULL_ZOOM_CHANGED = 0x04
};
/**
* This is called on a frame when there has been a change to one of its
* ancestors that might affect the frame too. SVGChangedFlags are passed
* to indicate what changed.
*
* Implementations do not need to invalidate, since the caller will
* invalidate the entire area of the ancestor that changed. However, they
* may need to update their bounds.
*/
virtual void NotifySVGChanged(uint32_t aFlags) = 0;
/**
* Get this frame's contribution to the rect returned by a GetBBox() call
* that occurred either on this element, or on one of its ancestors.
*
* SVG defines an element's bbox to be the element's fill bounds in the
* userspace established by that element. By allowing callers to pass in the
* transform from the userspace established by this element to the userspace
* established by an an ancestor, this method allows callers to obtain this
* element's fill bounds in the userspace established by that ancestor
* instead. In that case, since we return the bounds in a different userspace
* (the ancestor's), the bounds we return are not this element's bbox, but
* rather this element's contribution to the bbox of the ancestor.
*
* @param aToBBoxUserspace The transform from the userspace established by
* this element to the userspace established by the ancestor on which
* getBBox was called. This will be the identity matrix if we are the
* element on which getBBox was called.
*
* @param aFlags Flags indicating whether, stroke, for example, should be
* included in the bbox calculation.
*/
virtual SVGBBox GetBBoxContribution(const gfx::Matrix& aToBBoxUserspace,
uint32_t aFlags) = 0;
// Are we a container frame?
virtual bool IsDisplayContainer() = 0;
};
} // namespace mozilla
#endif // LAYOUT_SVG_ISVGDISPLAYABLEFRAME_H_
|
