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
|
/* -*- 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 __NS_SVGCLIPPATHFRAME_H__
#define __NS_SVGCLIPPATHFRAME_H__
#include "AutoReferenceLimiter.h"
#include "gfxMatrix.h"
#include "mozilla/Attributes.h"
#include "nsSVGContainerFrame.h"
#include "nsSVGUtils.h"
class gfxContext;
class nsISVGChildFrame;
class nsSVGClipPathFrame : public nsSVGContainerFrame
{
friend nsIFrame*
NS_NewSVGClipPathFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
typedef mozilla::gfx::Matrix Matrix;
typedef mozilla::gfx::SourceSurface SourceSurface;
typedef mozilla::image::DrawResult DrawResult;
protected:
explicit nsSVGClipPathFrame(nsStyleContext* aContext)
: nsSVGContainerFrame(aContext)
, mReferencing(mozilla::AutoReferenceLimiter::notReferencing)
{
AddStateBits(NS_FRAME_IS_NONDISPLAY);
}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame methods:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override {}
// nsSVGClipPathFrame methods:
/**
* Applies the clipPath by pushing a clip path onto the DrawTarget.
*
* This method must only be used if IsTrivial() returns true, otherwise use
* GetClipMask.
*
* @param aContext The context that the clip path is to be applied to.
* @param aClippedFrame The/an nsIFrame of the element that references this
* clipPath that is currently being processed.
* @param aMatrix The transform from aClippedFrame's user space to aContext's
* current transform.
*/
void ApplyClipPath(gfxContext& aContext,
nsIFrame* aClippedFrame,
const gfxMatrix &aMatrix);
/**
* Returns an alpha mask surface containing the clipping geometry.
*
* This method must only be used if IsTrivial() returns false, otherwise use
* ApplyClipPath.
*
* @param aReferenceContext Used to determine the backend for and size of the
* returned SourceSurface, the size being limited to the device space clip
* extents on the context.
* @param aClippedFrame The/an nsIFrame of the element that references this
* clipPath that is currently being processed.
* @param aMatrix The transform from aClippedFrame's user space to aContext's
* current transform.
* @param [out] aMaskTransform The transform to use with the returned
* surface.
* @param [in, optional] aExtraMask An extra surface that the returned
* surface should be masked with.
* @param [in, optional] aExtraMasksTransform The transform to use with
* aExtraMask. Should be passed when aExtraMask is passed.
* @param [out, optional] aResult returns the result of drawing action.
*/
already_AddRefed<SourceSurface>
GetClipMask(gfxContext& aReferenceContext, nsIFrame* aClippedFrame,
const gfxMatrix& aMatrix, Matrix* aMaskTransform,
SourceSurface* aExtraMask = nullptr,
const Matrix& aExtraMasksTransform = Matrix(),
DrawResult* aResult = nullptr);
/**
* aPoint is expected to be in aClippedFrame's SVG user space.
*/
bool PointIsInsideClipPath(nsIFrame* aClippedFrame, const gfxPoint &aPoint);
// Check if this clipPath is made up of more than one geometry object.
// If so, the clipping API in cairo isn't enough and we need to use
// mask based clipping.
bool IsTrivial(nsISVGChildFrame **aSingleChild = nullptr);
bool IsValid();
// nsIFrame interface:
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgClipPathFrame
*/
virtual nsIAtom* GetType() const override;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override
{
return MakeFrameName(NS_LITERAL_STRING("SVGClipPath"), aResult);
}
#endif
SVGBBox
GetBBoxForClipPathFrame(const SVGBBox &aBBox, const gfxMatrix &aMatrix);
/**
* If the clipPath element transforms its children due to
* clipPathUnits="objectBoundingBox" being set on it and/or due to the
* 'transform' attribute being set on it, this function returns the resulting
* transform.
*/
gfxMatrix GetClipPathTransform(nsIFrame* aClippedFrame);
private:
// nsSVGContainerFrame methods:
virtual gfxMatrix GetCanvasTM() override;
// Set, during a GetClipMask() call, to the transform that still needs to be
// concatenated to the transform of the DrawTarget that was passed to
// GetClipMask in order to establish the coordinate space that the clipPath
// establishes for its contents (i.e. including applying 'clipPathUnits' and
// any 'transform' attribute set on the clipPath) specifically for clipping
// the frame that was passed to GetClipMask at that moment in time. This is
// set so that if our GetCanvasTM method is called while GetClipMask is
// painting its children, the returned matrix will include the transforms
// that should be used when creating the mask for the frame passed to
// GetClipMask.
//
// Note: The removal of GetCanvasTM is nearly complete, so our GetCanvasTM
// may not even be called soon/any more.
gfxMatrix mMatrixForChildren;
// Flag used by AutoReferenceLimiter while we're processing an instance of
// this class to protect against (break) reference loops.
int16_t mReferencing;
};
#endif
|
