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
|
/* -*- 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 __NS_SVGPATHGEOMETRYELEMENT_H__
#define __NS_SVGPATHGEOMETRYELEMENT_H__
#include "mozilla/gfx/2D.h"
#include "SVGGraphicsElement.h"
struct nsSVGMark {
enum Type {
eStart,
eMid,
eEnd,
eTypeCount
};
float x, y, angle;
Type type;
nsSVGMark(float aX, float aY, float aAngle, Type aType) :
x(aX), y(aY), angle(aAngle), type(aType) {}
};
typedef mozilla::dom::SVGGraphicsElement nsSVGPathGeometryElementBase;
class nsSVGPathGeometryElement : public nsSVGPathGeometryElementBase
{
protected:
typedef mozilla::gfx::CapStyle CapStyle;
typedef mozilla::gfx::DrawTarget DrawTarget;
typedef mozilla::gfx::FillRule FillRule;
typedef mozilla::gfx::Float Float;
typedef mozilla::gfx::Matrix Matrix;
typedef mozilla::gfx::Path Path;
typedef mozilla::gfx::Point Point;
typedef mozilla::gfx::PathBuilder PathBuilder;
typedef mozilla::gfx::Rect Rect;
typedef mozilla::gfx::StrokeOptions StrokeOptions;
public:
explicit nsSVGPathGeometryElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
const nsAttrValue* aValue, bool aNotify) override;
/**
* Causes this element to discard any Path object that GetOrBuildPath may
* have cached.
*/
virtual void ClearAnyCachedPath() override final {
mCachedPath = nullptr;
}
virtual bool AttributeDefinesGeometry(const nsIAtom *aName);
/**
* Returns true if this element's geometry depends on the width or height of its
* coordinate context (typically the viewport established by its nearest <svg>
* ancestor). In other words, returns true if one of the attributes for which
* AttributeDefinesGeometry returns true has a percentage value.
*
* This could be moved up to a more general class so it can be used for non-leaf
* elements, but that would require care and for now there's no need.
*/
bool GeometryDependsOnCoordCtx();
virtual bool IsMarkable();
virtual void GetMarkPoints(nsTArray<nsSVGMark> *aMarks);
/**
* A method that can be faster than using a Moz2D Path and calling GetBounds/
* GetStrokedBounds on it. It also helps us avoid rounding error for simple
* shapes and simple transforms where the Moz2D Path backends can fail to
* produce the clean integer bounds that content authors expect in some cases.
*
* If |aToNonScalingStrokeSpace| is non-null then |aBounds|, which is computed
* in bounds space, has the property that it's the smallest (axis-aligned)
* rectangular bound containing the image of this shape as stroked in
* non-scaling-stroke space. (When all transforms involved are rectilinear
* the bounds of the image of |aBounds| in non-scaling-stroke space will be
* tight, but if there are non-rectilinear transforms involved then that may
* be impossible and this method will return false).
*
* If |aToNonScalingStrokeSpace| is non-null then |*aToNonScalingStrokeSpace|
* must be non-singular.
*/
virtual bool GetGeometryBounds(Rect* aBounds, const StrokeOptions& aStrokeOptions,
const Matrix& aToBoundsSpace,
const Matrix* aToNonScalingStrokeSpace = nullptr) {
return false;
}
/**
* For use with GetAsSimplePath.
*/
class SimplePath
{
public:
SimplePath()
: mType(NONE)
{}
bool IsPath() const {
return mType != NONE;
}
void SetRect(Float x, Float y, Float width, Float height) {
mX = x; mY = y, mWidthOrX2 = width, mHeightOrY2 = height;
mType = RECT;
}
Rect AsRect() const {
MOZ_ASSERT(mType == RECT);
return Rect(mX, mY, mWidthOrX2, mHeightOrY2);
}
bool IsRect() const {
return mType == RECT;
}
void SetLine(Float x1, Float y1, Float x2, Float y2) {
mX = x1, mY = y1, mWidthOrX2 = x2, mHeightOrY2 = y2;
mType = LINE;
}
Point Point1() const {
MOZ_ASSERT(mType == LINE);
return Point(mX, mY);
}
Point Point2() const {
MOZ_ASSERT(mType == LINE);
return Point(mWidthOrX2, mHeightOrY2);
}
bool IsLine() const {
return mType == LINE;
}
void Reset() {
mType = NONE;
}
private:
enum Type {
NONE, RECT, LINE
};
Float mX, mY, mWidthOrX2, mHeightOrY2;
Type mType;
};
/**
* For some platforms there is significant overhead to creating and painting
* a Moz2D Path object. For Rects and lines it is better to get the path data
* using this method and then use the optimized DrawTarget methods for
* filling/stroking rects and lines.
*/
virtual void GetAsSimplePath(SimplePath* aSimplePath) {
aSimplePath->Reset();
}
/**
* Returns a Path that can be used to paint, hit-test or calculate bounds for
* this element. May return nullptr if there is no [valid] path. The path
* that is created may be cached and returned on subsequent calls.
*/
virtual already_AddRefed<Path> GetOrBuildPath(const DrawTarget& aDrawTarget,
FillRule fillRule);
/**
* The same as GetOrBuildPath, but bypasses the cache (neither returns any
* previously cached Path, nor caches the Path that in does return).
* this element. May return nullptr if there is no [valid] path.
*/
virtual already_AddRefed<Path> BuildPath(PathBuilder* aBuilder) = 0;
/**
* Returns a Path that can be used to measure the length of this elements
* path, or to find the position at a given distance along it.
*
* This is currently equivalent to calling GetOrBuildPath, but it may not be
* in the future. The reason for this function to be separate from
* GetOrBuildPath is because SVGPathData::BuildPath inserts small lines into
* the path if zero length subpaths are encountered, in order to implement
* the SVG specifications requirements that zero length subpaths should
* render circles/squares if stroke-linecap is round/square, respectively.
* In principle these inserted lines could interfere with path measurement,
* so we keep callers that are looking to do measurement separate in case we
* run into problems with the inserted lines negatively affecting measuring
* for content.
*/
virtual already_AddRefed<Path> GetOrBuildPathForMeasuring();
/**
* Returns the current computed value of the CSS property 'fill-rule' for
* this element.
*/
FillRule GetFillRule();
protected:
mutable RefPtr<Path> mCachedPath;
};
#endif
|
