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
|
/* -*- 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 mozilla_dom_SVGTransform_h
#define mozilla_dom_SVGTransform_h
#include "DOMSVGTransformList.h"
#include "nsAutoPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsDebug.h"
#include "nsID.h"
#include "nsSVGTransform.h"
#include "nsWrapperCache.h"
#include "mozilla/Attributes.h"
class nsSVGElement;
class gfxMatrix;
#define MOZ_SVG_LIST_INDEX_BIT_COUNT 31 // supports > 2 billion list items
namespace mozilla {
namespace dom {
class SVGMatrix;
/**
* DOM wrapper for an SVG transform. See DOMSVGLength.h.
*/
class SVGTransform final : public nsWrapperCache
{
friend class AutoChangeTransformNotifier;
public:
NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(SVGTransform)
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(SVGTransform)
/**
* Generic ctor for SVGTransform objects that are created for an attribute.
*/
SVGTransform(DOMSVGTransformList *aList,
uint32_t aListIndex,
bool aIsAnimValItem);
/**
* Ctors for creating the objects returned by:
* SVGSVGElement.createSVGTransform(),
* SVGSVGElement.createSVGTransformFromMatrix(in SVGMatrix matrix),
* SVGTransformList.createSVGTransformFromMatrix(in SVGMatrix matrix)
* which do not initially belong to an attribute.
*/
explicit SVGTransform();
explicit SVGTransform(const gfxMatrix &aMatrix);
/**
* Ctor for creating an unowned copy. Used with Clone().
*/
explicit SVGTransform(const nsSVGTransform &aMatrix);
/**
* Create an unowned copy of an owned transform. The caller is responsible for
* the first AddRef().
*/
SVGTransform* Clone() {
NS_ASSERTION(mList, "unexpected caller");
return new SVGTransform(InternalItem());
}
bool IsInList() const {
return !!mList;
}
/**
* In future, if this class is used for non-list transforms, this will be
* different to IsInList().
*/
bool HasOwner() const {
return !!mList;
}
/**
* This method is called to notify this DOM object that it is being inserted
* into a list, and give it the information it needs as a result.
*
* This object MUST NOT already belong to a list when this method is called.
* That's not to say that script can't move these DOM objects between
* lists - it can - it's just that the logic to handle that (and send out
* the necessary notifications) is located elsewhere (in
* DOMSVGTransformList).)
*/
void InsertingIntoList(DOMSVGTransformList *aList,
uint32_t aListIndex,
bool aIsAnimValItem);
static uint32_t MaxListIndex() {
return (1U << MOZ_SVG_LIST_INDEX_BIT_COUNT) - 1;
}
/// This method is called to notify this object that its list index changed.
void UpdateListIndex(uint32_t aListIndex) {
mListIndex = aListIndex;
}
/**
* This method is called to notify this DOM object that it is about to be
* removed from its current DOM list so that it can first make a copy of its
* internal counterpart's values. (If it didn't do this, then it would
* "lose" its value on being removed.)
*/
void RemovingFromList();
nsSVGTransform ToSVGTransform() const {
return Transform();
}
// WebIDL
DOMSVGTransformList* GetParentObject() const { return mList; }
virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
uint16_t Type() const;
dom::SVGMatrix* GetMatrix();
float Angle() const;
void SetMatrix(dom::SVGMatrix& matrix, ErrorResult& rv);
void SetTranslate(float tx, float ty, ErrorResult& rv);
void SetScale(float sx, float sy, ErrorResult& rv);
void SetRotate(float angle, float cx, float cy, ErrorResult& rv);
void SetSkewX(float angle, ErrorResult& rv);
void SetSkewY(float angle, ErrorResult& rv);
protected:
~SVGTransform();
// Interface for SVGMatrix's use
friend class dom::SVGMatrix;
bool IsAnimVal() const {
return mIsAnimValItem;
}
const gfxMatrix& Matrixgfx() const {
return Transform().GetMatrix();
}
void SetMatrix(const gfxMatrix& aMatrix);
private:
nsSVGElement* Element() {
return mList->Element();
}
/**
* Get a reference to the internal nsSVGTransform list item that this DOM
* wrapper object currently wraps.
*/
nsSVGTransform& InternalItem();
const nsSVGTransform& InternalItem() const;
#ifdef DEBUG
bool IndexIsValid();
#endif
const nsSVGTransform& Transform() const {
return HasOwner() ? InternalItem() : *mTransform;
}
nsSVGTransform& Transform() {
return HasOwner() ? InternalItem() : *mTransform;
}
RefPtr<DOMSVGTransformList> mList;
// Bounds for the following are checked in the ctor, so be sure to update
// that if you change the capacity of any of the following.
uint32_t mListIndex:MOZ_SVG_LIST_INDEX_BIT_COUNT;
uint32_t mIsAnimValItem:1;
// Usually this class acts as a wrapper for an nsSVGTransform object which is
// part of a list and is accessed by going via the owning Element.
//
// However, in some circumstances, objects of this class may not be associated
// with any particular list and thus, no internal nsSVGTransform object. In
// that case we allocate an nsSVGTransform object on the heap to store the data.
nsAutoPtr<nsSVGTransform> mTransform;
};
} // namespace dom
} // namespace mozilla
#undef MOZ_SVG_LIST_INDEX_BIT_COUNT
#endif // mozilla_dom_SVGTransform_h
|
