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
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkGroupShape_DEFINED
#define SkGroupShape_DEFINED
#include "SkMatrix.h"
#include "SkShape.h"
#include "SkTDArray.h"
#include "SkThread.h"
template <typename T> class SkTRefCnt : public T {
public:
SkTRefCnt() : fRefCnt(1) {}
~SkTRefCnt() { SkASSERT(1 == fRefCnt); }
int32_t getRefCnt() const { return fRefCnt; }
/** Increment the reference count. Must be balanced by a call to unref().
*/
void ref() const {
SkASSERT(fRefCnt > 0);
sk_atomic_inc(&fRefCnt);
}
/** Decrement the reference count. If the reference count is 1 before the
decrement, then call delete on the object. Note that if this is the
case, then the object needs to have been allocated via new, and not on
the stack.
*/
void unref() const {
SkASSERT(fRefCnt > 0);
if (sk_atomic_dec(&fRefCnt) == 1) {
fRefCnt = 1; // so our destructor won't complain
SkDELETE(this);
}
}
static void SafeRef(const SkTRefCnt* obj) {
if (obj) {
obj->ref();
}
}
static void SafeUnref(const SkTRefCnt* obj) {
if (obj) {
obj->unref();
}
}
private:
mutable int32_t fRefCnt;
};
class SkMatrixRef : public SkTRefCnt<SkMatrix> {
public:
SkMatrixRef() { this->reset(); }
explicit SkMatrixRef(const SkMatrix& matrix) {
SkMatrix& m = *this;
m = matrix;
}
SkMatrix& operator=(const SkMatrix& matrix) {
SkMatrix& m = *this;
m = matrix;
return m;
}
};
class SkGroupShape : public SkShape {
public:
SkGroupShape();
virtual ~SkGroupShape();
/** Return the number of child shapes in this group
*/
int countShapes() const;
/** Return the shape at the specified index. Note this does not affect the
owner count of the index'd shape. If index is out of range, returns NULL
*/
SkShape* getShape(int index, SkMatrixRef** = NULL) const;
/** Helper function to return the matrixref of the specified shape.
*/
SkMatrixRef* getShapeMatrixRef(int index) const {
SkMatrixRef* mr = NULL;
(void)this->getShape(index, &mr);
return mr;
}
/** Ref the specified shape, and insert it into the child list at the
specified index. If index == countShapes(), then the shape will be
appended to the child list, otherwise if index is out of range, the
shape is not added. Either way, the shape parameter is returned.
Child shapes are drawn in order, after the parent, so the shape at index
0 will be drawn first, and the shape at index countShapes() - 1 will be
drawn last.
*/
void addShape(int index, SkShape*, SkMatrixRef* = NULL);
void addShape(int index, SkShape* shape, const SkMatrix& matrix) {
SkMatrixRef* mr = SkNEW_ARGS(SkMatrixRef, (matrix));
this->addShape(index, shape, mr);
mr->unref();
}
/** Helper method to append a shape, passing countShapes() for the index
*/
SkShape* appendShape(SkShape* shape, SkMatrixRef* mr = NULL) {
this->addShape(this->countShapes(), shape, mr);
return shape;
}
SkShape* appendShape(SkShape* shape, const SkMatrix& matrix) {
this->addShape(this->countShapes(), shape, matrix);
return shape;
}
/** Unref the specified index, and remove it from the child list. If index
is out of range, does nothing.
*/
void removeShape(int index);
/** Unrefs and removes all of the child shapes
*/
void removeAllShapes();
// overrides
virtual Factory getFactory();
virtual void flatten(SkFlattenableWriteBuffer&);
// public for Registrar
static SkFlattenable* CreateProc(SkFlattenableReadBuffer&);
SK_DECLARE_FLATTENABLE_REGISTRAR()
protected:
// overrides
virtual void onDraw(SkCanvas*);
SkGroupShape(SkFlattenableReadBuffer&);
private:
struct Rec {
SkShape* fShape;
SkMatrixRef* fMatrixRef;
};
SkTDArray<Rec> fList;
typedef SkShape INHERITED;
};
#endif
|
