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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 NSSVGINTEGRATIONUTILS_H_
#define NSSVGINTEGRATIONUTILS_H_
#include "gfxMatrix.h"
#include "gfxRect.h"
#include "nsRegionFwd.h"
#include "mozilla/gfx/Rect.h"
#include "imgIContainer.h"
class gfxContext;
class gfxDrawable;
class nsDisplayList;
class nsDisplayListBuilder;
class nsIFrame;
struct nsRect;
namespace mozilla {
namespace gfx {
class DrawTarget;
} // namespace gfx
namespace layers {
class LayerManager;
} // namespace layers
} // namespace mozilla
struct nsPoint;
struct nsSize;
/**
* Integration of SVG effects (clipPath clipping, masking and filters) into
* regular display list based painting and hit-testing.
*/
class nsSVGIntegrationUtils final
{
typedef mozilla::gfx::DrawTarget DrawTarget;
typedef mozilla::gfx::IntRect IntRect;
typedef mozilla::image::DrawResult DrawResult;
public:
/**
* Returns true if SVG effects are currently applied to this frame.
*/
static bool
UsingEffectsForFrame(const nsIFrame* aFrame);
/**
* Returns true if mask or clippath are currently applied to this frame.
*/
static bool
UsingMaskOrClipPathForFrame(const nsIFrame* aFrame);
/**
* Returns the size of the union of the border-box rects of all of
* aNonSVGFrame's continuations.
*/
static nsSize
GetContinuationUnionSize(nsIFrame* aNonSVGFrame);
/**
* When SVG effects need to resolve percentage, userSpaceOnUse lengths, they
* need a coordinate context to resolve them against. This method provides
* that coordinate context for non-SVG frames with SVG effects applied to
* them. The gfxSize returned is the size of the union of all of the given
* frame's continuations' border boxes, converted to SVG user units (equal to
* CSS px units), as required by the SVG code.
*/
static mozilla::gfx::Size
GetSVGCoordContextForNonSVGFrame(nsIFrame* aNonSVGFrame);
/**
* SVG effects such as SVG filters, masking and clipPath may require an SVG
* "bbox" for the element they're being applied to in order to make decisions
* about positioning, and to resolve various lengths against. This method
* provides the "bbox" for non-SVG frames. The bbox returned is in CSS px
* units, and is the union of all aNonSVGFrame's continuations' overflow
* areas, relative to the top-left of the union of all aNonSVGFrame's
* continuations' border box rects.
*/
static gfxRect
GetSVGBBoxForNonSVGFrame(nsIFrame* aNonSVGFrame);
/**
* Used to adjust a frame's pre-effects visual overflow rect to take account
* of SVG effects.
*
* XXX This method will not do the right thing for frames with continuations.
* It really needs all the continuations to have been reflowed before being
* called, but we currently call it on each continuation as its overflow
* rects are set during the reflow of each particular continuation. Gecko's
* current reflow architecture does not allow us to set the overflow rects
* for a whole chain of continuations for a given element at the point when
* the last continuation is reflowed. See:
* http://groups.google.com/group/mozilla.dev.tech.layout/msg/6b179066f3051f65
*/
static nsRect
ComputePostEffectsVisualOverflowRect(nsIFrame* aFrame,
const nsRect& aPreEffectsOverflowRect);
/**
* Used to adjust the area of a frame that needs to be invalidated to take
* account of SVG effects.
*
* @param aFrame The effects frame.
* @param aToReferenceFrame The offset (in app units) from aFrame to its
* reference display item.
* @param aInvalidRegion The pre-effects invalid region in pixels relative to
* the reference display item.
* @return The post-effects invalid rect in pixels relative to the reference
* display item.
*/
static nsIntRegion
AdjustInvalidAreaForSVGEffects(nsIFrame* aFrame, const nsPoint& aToReferenceFrame,
const nsIntRegion& aInvalidRegion);
/**
* Figure out which area of the source is needed given an area to
* repaint
*/
static nsRect
GetRequiredSourceForInvalidArea(nsIFrame* aFrame, const nsRect& aDamageRect);
/**
* Returns true if the given point is not clipped out by effects.
* @param aPt in appunits relative to aFrame
*/
static bool
HitTestFrameForEffects(nsIFrame* aFrame, const nsPoint& aPt);
struct PaintFramesParams {
gfxContext& ctx;
nsIFrame* frame;
const nsRect& dirtyRect;
const nsRect& borderArea;
nsDisplayListBuilder* builder;
mozilla::layers::LayerManager* layerManager;
bool handleOpacity; // If true, PaintMaskAndClipPath/ PaintFilter should
// apply css opacity.
IntRect maskRect;
explicit PaintFramesParams(gfxContext& aCtx, nsIFrame* aFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsDisplayListBuilder* aBuilder,
mozilla::layers::LayerManager* aLayerManager,
bool aHandleOpacity)
: ctx(aCtx), frame(aFrame), dirtyRect(aDirtyRect),
borderArea(aBorderArea), builder(aBuilder),
layerManager(aLayerManager), handleOpacity(aHandleOpacity)
{ }
};
/**
* Paint non-SVG frame with mask, clipPath and opacity effect.
*/
static DrawResult
PaintMaskAndClipPath(const PaintFramesParams& aParams);
/**
* Paint mask of non-SVG frame onto a given context, aParams.ctx.
* aParams.ctx must contain an A8 surface.
*/
static DrawResult
PaintMask(const PaintFramesParams& aParams);
/**
* Return true if all the mask resource of aFrame are ready.
*/
static bool
IsMaskResourceReady(nsIFrame* aFrame);
/**
* Paint non-SVG frame with filter and opacity effect.
*/
static DrawResult
PaintFilter(const PaintFramesParams& aParams);
/**
* SVG frames expect to paint in SVG user units, which are equal to CSS px
* units. This method provides a transform matrix to multiply onto a
* gfxContext's current transform to convert the context's current units from
* its usual dev pixels to SVG user units/CSS px to keep the SVG code happy.
*/
static gfxMatrix
GetCSSPxToDevPxMatrix(nsIFrame* aNonSVGFrame);
/**
* @param aRenderingContext the target rendering context in which the paint
* server will be rendered
* @param aTarget the target frame onto which the paint server will be
* rendered
* @param aPaintServer a first-continuation frame to use as the source
* @param aFilter a filter to be applied when scaling
* @param aDest the area the paint server image should be mapped to
* @param aFill the area to be filled with copies of the paint server image
* @param aAnchor a point in aFill which we will ensure is pixel-aligned in
* the output
* @param aDirty pixels outside this area may be skipped
* @param aPaintServerSize the size that would be filled when using
* background-repeat:no-repeat and background-size:auto. For normal background
* images, this would be the intrinsic size of the image; for gradients and
* patterns this would be the whole target frame fill area.
* @param aFlags pass FLAG_SYNC_DECODE_IMAGES and any images in the paint
* server will be decoding synchronously if they are not decoded already.
*/
enum {
FLAG_SYNC_DECODE_IMAGES = 0x01,
};
static already_AddRefed<gfxDrawable>
DrawableFromPaintServer(nsIFrame* aFrame,
nsIFrame* aTarget,
const nsSize& aPaintServerSize,
const mozilla::gfx::IntSize& aRenderSize,
const DrawTarget* aDrawTarget,
const gfxMatrix& aContextMatrix,
uint32_t aFlags);
/**
* For non-SVG frames, this gives the offset to the frame's "user space".
* For SVG frames, this returns a zero offset.
*/
static nsPoint
GetOffsetToBoundingBox(nsIFrame* aFrame);
};
#endif /*NSSVGINTEGRATIONUTILS_H_*/
|
