OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2012 Google Inc. | 3 * Copyright 2012 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #ifndef SKDRAWCOMMAND_H_ | 9 #ifndef SKDRAWCOMMAND_H_ |
10 #define SKDRAWCOMMAND_H_ | 10 #define SKDRAWCOMMAND_H_ |
11 | 11 |
12 #include "SkPictureFlat.h" | 12 #include "SkPictureFlat.h" |
13 #include "SkCanvas.h" | 13 #include "SkCanvas.h" |
14 #include "SkString.h" | 14 #include "SkString.h" |
15 | 15 |
16 class SK_API SkDrawCommand { | 16 class SK_API SkDrawCommand { |
17 public: | 17 public: |
| 18 /* TODO(chudy): Remove subclasses. */ |
18 SkDrawCommand(DrawType drawType); | 19 SkDrawCommand(DrawType drawType); |
| 20 SkDrawCommand(); |
19 | 21 |
20 virtual ~SkDrawCommand(); | 22 virtual ~SkDrawCommand(); |
21 | 23 |
22 virtual SkString toString() const; | 24 virtual SkString toString(); |
23 | 25 |
24 void setOffset(size_t offset) { fOffset = offset; } | 26 void setOffset(size_t offset) { fOffset = offset; } |
25 size_t offset() const { return fOffset; } | 27 virtual size_t offset() { return fOffset; } |
26 | 28 |
27 virtual const char* toCString() const { | 29 virtual const char* toCString() { |
28 return GetCommandString(fDrawType); | 30 return GetCommandString(fDrawType); |
29 } | 31 } |
30 | 32 |
31 bool isVisible() const { | 33 bool isVisible() const { |
32 return fVisible; | 34 return fVisible; |
33 } | 35 } |
34 | 36 |
35 void setVisible(bool toggle) { | 37 void setVisible(bool toggle) { |
36 fVisible = toggle; | 38 fVisible = toggle; |
37 } | 39 } |
38 | 40 |
39 const SkTDArray<SkString*>* Info() const { return &fInfo; } | 41 SkTDArray<SkString*>* Info() {return &fInfo; }; |
40 virtual void execute(SkCanvas*) const = 0; | 42 virtual void execute(SkCanvas* canvas) = 0; |
41 virtual void vizExecute(SkCanvas*) const {} | 43 virtual void vizExecute(SkCanvas* canvas) { }; |
42 | 44 |
43 virtual void setUserMatrix(const SkMatrix&) {} | 45 virtual void setUserMatrix(const SkMatrix& userMtx) { }; |
44 | 46 |
45 /** Does nothing by default, but used by save() and restore()-type | 47 /** Does nothing by default, but used by save() and restore()-type |
46 subclasses to track unresolved save() calls. */ | 48 subclasses to track unresolved save() calls. */ |
47 virtual void trackSaveState(int* state) {} | 49 virtual void trackSaveState(int* state) { }; |
48 | 50 |
49 // The next "active" system is only used by save, saveLayer, restore, | 51 // The next "active" system is only used by save, saveLayer, restore, |
50 // pushCull and popCull. It is used in two ways: | 52 // pushCull and popCull. It is used in two ways: |
51 // To determine which saveLayers are currently active (at a | 53 // To determine which saveLayers are currently active (at a |
52 // given point in the rendering). | 54 // given point in the rendering). |
53 // saves just return a kPushLayer action but don't track active state | 55 // saves just return a kPushLayer action but don't track active state |
54 // restores just return a kPopLayer action | 56 // restores just return a kPopLayer action |
55 // saveLayers return kPushLayer but also track the active state | 57 // saveLayers return kPushLayer but also track the active state |
56 // To determine which culls are currently active (at a given point) | 58 // To determine which culls are currently active (at a given point) |
57 // in the rendering). | 59 // in the rendering). |
58 // pushCulls return a kPushCull action | 60 // pushCulls return a kPushCull action |
59 // popCulls return a kPopCull action | 61 // popCulls return a kPopCull action |
60 enum Action { | 62 enum Action { |
61 kNone_Action, | 63 kNone_Action, |
62 kPopLayer_Action, | 64 kPopLayer_Action, |
63 kPushLayer_Action, | 65 kPushLayer_Action, |
64 kPopCull_Action, | 66 kPopCull_Action, |
65 kPushCull_Action | 67 kPushCull_Action |
66 }; | 68 }; |
67 virtual Action action() const { return kNone_Action; } | 69 virtual Action action() const { return kNone_Action; } |
68 virtual void setActive(bool active) {} | 70 virtual void setActive(bool active) {} |
69 virtual bool active() const { return false; } | 71 virtual bool active() const { return false; } |
70 | 72 |
71 DrawType getType() const { return fDrawType; } | 73 DrawType getType() { return fDrawType; }; |
72 | 74 |
73 virtual bool render(SkCanvas* canvas) const { return false; } | 75 virtual bool render(SkCanvas* canvas) const { return false; } |
74 | 76 |
75 static const char* GetCommandString(DrawType type); | 77 static const char* GetCommandString(DrawType type); |
76 | 78 |
77 protected: | 79 protected: |
78 SkTDArray<SkString*> fInfo; | 80 SkTDArray<SkString*> fInfo; |
79 | 81 |
80 private: | 82 private: |
81 DrawType fDrawType; | 83 DrawType fDrawType; |
82 size_t fOffset; | 84 size_t fOffset; |
83 bool fVisible; | 85 bool fVisible; |
84 }; | 86 }; |
85 | 87 |
86 class SkRestoreCommand : public SkDrawCommand { | 88 class SkRestoreCommand : public SkDrawCommand { |
87 public: | 89 public: |
88 SkRestoreCommand(); | 90 SkRestoreCommand(); |
89 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 91 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
90 virtual void trackSaveState(int* state) SK_OVERRIDE; | 92 virtual void trackSaveState(int* state) SK_OVERRIDE; |
91 virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; } | 93 virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; } |
92 | 94 |
93 private: | 95 private: |
94 typedef SkDrawCommand INHERITED; | 96 typedef SkDrawCommand INHERITED; |
95 }; | 97 }; |
96 | 98 |
97 class SkClearCommand : public SkDrawCommand { | 99 class SkClearCommand : public SkDrawCommand { |
98 public: | 100 public: |
99 SkClearCommand(SkColor color); | 101 SkClearCommand(SkColor color); |
100 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 102 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
101 private: | 103 private: |
102 SkColor fColor; | 104 SkColor fColor; |
103 | 105 |
104 typedef SkDrawCommand INHERITED; | 106 typedef SkDrawCommand INHERITED; |
105 }; | 107 }; |
106 | 108 |
107 class SkClipPathCommand : public SkDrawCommand { | 109 class SkClipPathCommand : public SkDrawCommand { |
108 public: | 110 public: |
109 SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA); | 111 SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA); |
110 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 112 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
111 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 113 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
112 private: | 114 private: |
113 SkPath fPath; | 115 SkPath fPath; |
114 SkRegion::Op fOp; | 116 SkRegion::Op fOp; |
115 bool fDoAA; | 117 bool fDoAA; |
116 | 118 |
117 typedef SkDrawCommand INHERITED; | 119 typedef SkDrawCommand INHERITED; |
118 }; | 120 }; |
119 | 121 |
120 class SkClipRegionCommand : public SkDrawCommand { | 122 class SkClipRegionCommand : public SkDrawCommand { |
121 public: | 123 public: |
122 SkClipRegionCommand(const SkRegion& region, SkRegion::Op op); | 124 SkClipRegionCommand(const SkRegion& region, SkRegion::Op op); |
123 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 125 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
124 private: | 126 private: |
125 SkRegion fRegion; | 127 SkRegion fRegion; |
126 SkRegion::Op fOp; | 128 SkRegion::Op fOp; |
127 | 129 |
128 typedef SkDrawCommand INHERITED; | 130 typedef SkDrawCommand INHERITED; |
129 }; | 131 }; |
130 | 132 |
131 class SkClipRectCommand : public SkDrawCommand { | 133 class SkClipRectCommand : public SkDrawCommand { |
132 public: | 134 public: |
133 SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA); | 135 SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA); |
134 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 136 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
135 | 137 |
136 const SkRect& rect() const { return fRect; } | 138 const SkRect& rect() const { return fRect; } |
137 SkRegion::Op op() const { return fOp; } | 139 SkRegion::Op op() const { return fOp; } |
138 bool doAA() const { return fDoAA; } | 140 bool doAA() const { return fDoAA; } |
139 | 141 |
140 private: | 142 private: |
141 SkRect fRect; | 143 SkRect fRect; |
142 SkRegion::Op fOp; | 144 SkRegion::Op fOp; |
143 bool fDoAA; | 145 bool fDoAA; |
144 | 146 |
145 typedef SkDrawCommand INHERITED; | 147 typedef SkDrawCommand INHERITED; |
146 }; | 148 }; |
147 | 149 |
148 class SkClipRRectCommand : public SkDrawCommand { | 150 class SkClipRRectCommand : public SkDrawCommand { |
149 public: | 151 public: |
150 SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA); | 152 SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA); |
151 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 153 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
152 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 154 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
153 | 155 |
154 const SkRRect& rrect() const { return fRRect; } | 156 const SkRRect& rrect() const { return fRRect; } |
155 SkRegion::Op op() const { return fOp; } | 157 SkRegion::Op op() const { return fOp; } |
156 bool doAA() const { return fDoAA; } | 158 bool doAA() const { return fDoAA; } |
157 | 159 |
158 private: | 160 private: |
159 SkRRect fRRect; | 161 SkRRect fRRect; |
160 SkRegion::Op fOp; | 162 SkRegion::Op fOp; |
161 bool fDoAA; | 163 bool fDoAA; |
162 | 164 |
163 typedef SkDrawCommand INHERITED; | 165 typedef SkDrawCommand INHERITED; |
164 }; | 166 }; |
165 | 167 |
166 class SkConcatCommand : public SkDrawCommand { | 168 class SkConcatCommand : public SkDrawCommand { |
167 public: | 169 public: |
168 SkConcatCommand(const SkMatrix& matrix); | 170 SkConcatCommand(const SkMatrix& matrix); |
169 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 171 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
170 private: | 172 private: |
171 SkMatrix fMatrix; | 173 SkMatrix fMatrix; |
172 | 174 |
173 typedef SkDrawCommand INHERITED; | 175 typedef SkDrawCommand INHERITED; |
174 }; | 176 }; |
175 | 177 |
176 class SkDrawBitmapCommand : public SkDrawCommand { | 178 class SkDrawBitmapCommand : public SkDrawCommand { |
177 public: | 179 public: |
178 SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, | 180 SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, |
179 const SkPaint* paint); | 181 const SkPaint* paint); |
180 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 182 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
181 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 183 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
182 private: | 184 private: |
183 SkBitmap fBitmap; | 185 SkBitmap fBitmap; |
184 SkScalar fLeft; | 186 SkScalar fLeft; |
185 SkScalar fTop; | 187 SkScalar fTop; |
186 SkPaint fPaint; | 188 SkPaint fPaint; |
187 SkPaint* fPaintPtr; | 189 SkPaint* fPaintPtr; |
188 | 190 |
189 typedef SkDrawCommand INHERITED; | 191 typedef SkDrawCommand INHERITED; |
190 }; | 192 }; |
191 | 193 |
192 class SkDrawBitmapMatrixCommand : public SkDrawCommand { | 194 class SkDrawBitmapMatrixCommand : public SkDrawCommand { |
193 public: | 195 public: |
194 SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix, | 196 SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix, |
195 const SkPaint* paint); | 197 const SkPaint* paint); |
196 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 198 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
197 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 199 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
198 private: | 200 private: |
199 SkBitmap fBitmap; | 201 SkBitmap fBitmap; |
200 SkMatrix fMatrix; | 202 SkMatrix fMatrix; |
201 SkPaint fPaint; | 203 SkPaint fPaint; |
202 SkPaint* fPaintPtr; | 204 SkPaint* fPaintPtr; |
203 | 205 |
204 typedef SkDrawCommand INHERITED; | 206 typedef SkDrawCommand INHERITED; |
205 }; | 207 }; |
206 | 208 |
207 class SkDrawBitmapNineCommand : public SkDrawCommand { | 209 class SkDrawBitmapNineCommand : public SkDrawCommand { |
208 public: | 210 public: |
209 SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, | 211 SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, |
210 const SkRect& dst, const SkPaint* paint); | 212 const SkRect& dst, const SkPaint* paint); |
211 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 213 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
212 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 214 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
213 private: | 215 private: |
214 SkBitmap fBitmap; | 216 SkBitmap fBitmap; |
215 SkIRect fCenter; | 217 SkIRect fCenter; |
216 SkRect fDst; | 218 SkRect fDst; |
217 SkPaint fPaint; | 219 SkPaint fPaint; |
218 SkPaint* fPaintPtr; | 220 SkPaint* fPaintPtr; |
219 | 221 |
220 typedef SkDrawCommand INHERITED; | 222 typedef SkDrawCommand INHERITED; |
221 }; | 223 }; |
222 | 224 |
223 class SkDrawBitmapRectCommand : public SkDrawCommand { | 225 class SkDrawBitmapRectCommand : public SkDrawCommand { |
224 public: | 226 public: |
225 SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, | 227 SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, |
226 const SkRect& dst, const SkPaint* paint, | 228 const SkRect& dst, const SkPaint* paint, |
227 SkCanvas::DrawBitmapRectFlags flags); | 229 SkCanvas::DrawBitmapRectFlags flags); |
228 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 230 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
229 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 231 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
230 | 232 |
231 const SkBitmap& bitmap() const { return fBitmap; } | 233 const SkBitmap& bitmap() const { return fBitmap; } |
232 | 234 |
233 // The non-const 'paint' method allows modification of this object's | 235 // The non-const 'paint' method allows modification of this object's |
234 // SkPaint. For this reason the ctor and setPaint method make a local copy. | 236 // SkPaint. For this reason the ctor and setPaint method make a local copy. |
235 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid | 237 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid |
236 // (since only an SkPaint* is passed into the ctor). | 238 // (since only an SkPaint* is passed into the ctor). |
237 const SkPaint* paint() const { return fPaintPtr; } | 239 const SkPaint* paint() const { return fPaintPtr; } |
238 SkPaint* paint() { return fPaintPtr; } | 240 SkPaint* paint() { return fPaintPtr; } |
(...skipping 17 matching lines...) Expand all Loading... |
256 SkPaint* fPaintPtr; | 258 SkPaint* fPaintPtr; |
257 SkCanvas::DrawBitmapRectFlags fFlags; | 259 SkCanvas::DrawBitmapRectFlags fFlags; |
258 | 260 |
259 typedef SkDrawCommand INHERITED; | 261 typedef SkDrawCommand INHERITED; |
260 }; | 262 }; |
261 | 263 |
262 class SkDrawDataCommand : public SkDrawCommand { | 264 class SkDrawDataCommand : public SkDrawCommand { |
263 public: | 265 public: |
264 SkDrawDataCommand(const void* data, size_t length); | 266 SkDrawDataCommand(const void* data, size_t length); |
265 virtual ~SkDrawDataCommand() { delete [] fData; } | 267 virtual ~SkDrawDataCommand() { delete [] fData; } |
266 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 268 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
267 private: | 269 private: |
268 char* fData; | 270 char* fData; |
269 size_t fLength; | 271 size_t fLength; |
270 | 272 |
271 typedef SkDrawCommand INHERITED; | 273 typedef SkDrawCommand INHERITED; |
272 }; | 274 }; |
273 | 275 |
274 class SkBeginCommentGroupCommand : public SkDrawCommand { | 276 class SkBeginCommentGroupCommand : public SkDrawCommand { |
275 public: | 277 public: |
276 SkBeginCommentGroupCommand(const char* description); | 278 SkBeginCommentGroupCommand(const char* description); |
277 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE { | 279 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { |
278 canvas->beginCommentGroup(fDescription.c_str()); | 280 canvas->beginCommentGroup(fDescription.c_str()); |
279 }; | 281 }; |
280 private: | 282 private: |
281 SkString fDescription; | 283 SkString fDescription; |
282 | 284 |
283 typedef SkDrawCommand INHERITED; | 285 typedef SkDrawCommand INHERITED; |
284 }; | 286 }; |
285 | 287 |
286 class SkCommentCommand : public SkDrawCommand { | 288 class SkCommentCommand : public SkDrawCommand { |
287 public: | 289 public: |
288 SkCommentCommand(const char* kywd, const char* value); | 290 SkCommentCommand(const char* kywd, const char* value); |
289 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE { | 291 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { |
290 canvas->addComment(fKywd.c_str(), fValue.c_str()); | 292 canvas->addComment(fKywd.c_str(), fValue.c_str()); |
291 }; | 293 }; |
292 private: | 294 private: |
293 SkString fKywd; | 295 SkString fKywd; |
294 SkString fValue; | 296 SkString fValue; |
295 | 297 |
296 typedef SkDrawCommand INHERITED; | 298 typedef SkDrawCommand INHERITED; |
297 }; | 299 }; |
298 | 300 |
299 class SkEndCommentGroupCommand : public SkDrawCommand { | 301 class SkEndCommentGroupCommand : public SkDrawCommand { |
300 public: | 302 public: |
301 SkEndCommentGroupCommand(); | 303 SkEndCommentGroupCommand(); |
302 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE { | 304 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { |
303 canvas->endCommentGroup(); | 305 canvas->endCommentGroup(); |
304 }; | 306 }; |
305 private: | 307 private: |
306 typedef SkDrawCommand INHERITED; | 308 typedef SkDrawCommand INHERITED; |
307 }; | 309 }; |
308 | 310 |
309 class SkDrawOvalCommand : public SkDrawCommand { | 311 class SkDrawOvalCommand : public SkDrawCommand { |
310 public: | 312 public: |
311 SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint); | 313 SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint); |
312 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 314 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
313 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 315 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
314 private: | 316 private: |
315 SkRect fOval; | 317 SkRect fOval; |
316 SkPaint fPaint; | 318 SkPaint fPaint; |
317 | 319 |
318 typedef SkDrawCommand INHERITED; | 320 typedef SkDrawCommand INHERITED; |
319 }; | 321 }; |
320 | 322 |
321 class SkDrawPaintCommand : public SkDrawCommand { | 323 class SkDrawPaintCommand : public SkDrawCommand { |
322 public: | 324 public: |
323 SkDrawPaintCommand(const SkPaint& paint); | 325 SkDrawPaintCommand(const SkPaint& paint); |
324 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 326 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
325 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 327 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
326 private: | 328 private: |
327 SkPaint fPaint; | 329 SkPaint fPaint; |
328 | 330 |
329 typedef SkDrawCommand INHERITED; | 331 typedef SkDrawCommand INHERITED; |
330 }; | 332 }; |
331 | 333 |
332 class SkDrawPathCommand : public SkDrawCommand { | 334 class SkDrawPathCommand : public SkDrawCommand { |
333 public: | 335 public: |
334 SkDrawPathCommand(const SkPath& path, const SkPaint& paint); | 336 SkDrawPathCommand(const SkPath& path, const SkPaint& paint); |
335 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 337 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
336 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 338 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
337 | 339 |
338 private: | 340 private: |
339 SkPath fPath; | 341 SkPath fPath; |
340 SkPaint fPaint; | 342 SkPaint fPaint; |
341 | 343 |
342 typedef SkDrawCommand INHERITED; | 344 typedef SkDrawCommand INHERITED; |
343 }; | 345 }; |
344 | 346 |
345 class SkDrawPictureCommand : public SkDrawCommand { | 347 class SkDrawPictureCommand : public SkDrawCommand { |
346 public: | 348 public: |
347 SkDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const
SkPaint* paint); | 349 SkDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const
SkPaint* paint); |
348 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 350 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
349 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 351 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
350 | 352 |
351 private: | 353 private: |
352 SkAutoTUnref<const SkPicture> fPicture; | 354 SkAutoTUnref<const SkPicture> fPicture; |
353 SkMatrix fMatrix; | 355 SkMatrix fMatrix; |
354 SkMatrix* fMatrixPtr; | 356 SkMatrix* fMatrixPtr; |
355 SkPaint fPaint; | 357 SkPaint fPaint; |
356 SkPaint* fPaintPtr; | 358 SkPaint* fPaintPtr; |
357 | 359 |
358 typedef SkDrawCommand INHERITED; | 360 typedef SkDrawCommand INHERITED; |
359 }; | 361 }; |
360 | 362 |
361 class SkDrawPointsCommand : public SkDrawCommand { | 363 class SkDrawPointsCommand : public SkDrawCommand { |
362 public: | 364 public: |
363 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pt
s[], | 365 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pt
s[], |
364 const SkPaint& paint); | 366 const SkPaint& paint); |
365 virtual ~SkDrawPointsCommand() { delete [] fPts; } | 367 virtual ~SkDrawPointsCommand() { delete [] fPts; } |
366 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 368 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
367 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 369 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
368 private: | 370 private: |
369 SkCanvas::PointMode fMode; | 371 SkCanvas::PointMode fMode; |
370 size_t fCount; | 372 size_t fCount; |
371 SkPoint* fPts; | 373 SkPoint* fPts; |
372 SkPaint fPaint; | 374 SkPaint fPaint; |
373 | 375 |
374 typedef SkDrawCommand INHERITED; | 376 typedef SkDrawCommand INHERITED; |
375 }; | 377 }; |
376 | 378 |
377 class SkDrawTextCommand : public SkDrawCommand { | 379 class SkDrawTextCommand : public SkDrawCommand { |
378 public: | 380 public: |
379 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar
y, | 381 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar
y, |
380 const SkPaint& paint); | 382 const SkPaint& paint); |
381 virtual ~SkDrawTextCommand() { delete [] fText; } | 383 virtual ~SkDrawTextCommand() { delete [] fText; } |
382 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 384 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
383 private: | 385 private: |
384 char* fText; | 386 char* fText; |
385 size_t fByteLength; | 387 size_t fByteLength; |
386 SkScalar fX; | 388 SkScalar fX; |
387 SkScalar fY; | 389 SkScalar fY; |
388 SkPaint fPaint; | 390 SkPaint fPaint; |
389 | 391 |
390 typedef SkDrawCommand INHERITED; | 392 typedef SkDrawCommand INHERITED; |
391 }; | 393 }; |
392 | 394 |
393 class SkDrawPosTextCommand : public SkDrawCommand { | 395 class SkDrawPosTextCommand : public SkDrawCommand { |
394 public: | 396 public: |
395 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[
], | 397 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[
], |
396 const SkPaint& paint); | 398 const SkPaint& paint); |
397 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } | 399 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } |
398 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 400 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
399 private: | 401 private: |
400 char* fText; | 402 char* fText; |
401 size_t fByteLength; | 403 size_t fByteLength; |
402 SkPoint* fPos; | 404 SkPoint* fPos; |
403 SkPaint fPaint; | 405 SkPaint fPaint; |
404 | 406 |
405 typedef SkDrawCommand INHERITED; | 407 typedef SkDrawCommand INHERITED; |
406 }; | 408 }; |
407 | 409 |
408 class SkDrawTextOnPathCommand : public SkDrawCommand { | 410 class SkDrawTextOnPathCommand : public SkDrawCommand { |
409 public: | 411 public: |
410 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& p
ath, | 412 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& p
ath, |
411 const SkMatrix* matrix, const SkPaint& paint); | 413 const SkMatrix* matrix, const SkPaint& paint); |
412 virtual ~SkDrawTextOnPathCommand() { delete [] fText; } | 414 virtual ~SkDrawTextOnPathCommand() { delete [] fText; } |
413 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 415 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
414 private: | 416 private: |
415 char* fText; | 417 char* fText; |
416 size_t fByteLength; | 418 size_t fByteLength; |
417 SkPath fPath; | 419 SkPath fPath; |
418 SkMatrix fMatrix; | 420 SkMatrix fMatrix; |
419 SkPaint fPaint; | 421 SkPaint fPaint; |
420 | 422 |
421 typedef SkDrawCommand INHERITED; | 423 typedef SkDrawCommand INHERITED; |
422 }; | 424 }; |
423 | 425 |
424 class SkDrawPosTextHCommand : public SkDrawCommand { | 426 class SkDrawPosTextHCommand : public SkDrawCommand { |
425 public: | 427 public: |
426 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xp
os[], | 428 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xp
os[], |
427 SkScalar constY, const SkPaint& paint); | 429 SkScalar constY, const SkPaint& paint); |
428 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } | 430 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } |
429 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 431 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
430 private: | 432 private: |
431 SkScalar* fXpos; | 433 SkScalar* fXpos; |
432 char* fText; | 434 char* fText; |
433 size_t fByteLength; | 435 size_t fByteLength; |
434 SkScalar fConstY; | 436 SkScalar fConstY; |
435 SkPaint fPaint; | 437 SkPaint fPaint; |
436 | 438 |
437 typedef SkDrawCommand INHERITED; | 439 typedef SkDrawCommand INHERITED; |
438 }; | 440 }; |
439 | 441 |
440 class SkDrawTextBlobCommand : public SkDrawCommand { | 442 class SkDrawTextBlobCommand : public SkDrawCommand { |
441 public: | 443 public: |
442 SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x, SkScalar y, const
SkPaint& paint); | 444 SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x, SkScalar y, const
SkPaint& paint); |
443 | 445 |
444 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 446 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
445 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 447 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
446 | 448 |
447 private: | 449 private: |
448 SkAutoTUnref<const SkTextBlob> fBlob; | 450 SkAutoTUnref<const SkTextBlob> fBlob; |
449 SkScalar fXPos; | 451 SkScalar fXPos; |
450 SkScalar fYPos; | 452 SkScalar fYPos; |
451 SkPaint fPaint; | 453 SkPaint fPaint; |
452 | 454 |
453 typedef SkDrawCommand INHERITED; | 455 typedef SkDrawCommand INHERITED; |
454 }; | 456 }; |
455 | 457 |
456 class SkDrawRectCommand : public SkDrawCommand { | 458 class SkDrawRectCommand : public SkDrawCommand { |
457 public: | 459 public: |
458 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); | 460 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); |
459 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 461 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
460 | 462 |
461 const SkRect& rect() const { return fRect; } | 463 const SkRect& rect() const { return fRect; } |
462 const SkPaint& paint() const { return fPaint; } | 464 const SkPaint& paint() const { return fPaint; } |
463 private: | 465 private: |
464 SkRect fRect; | 466 SkRect fRect; |
465 SkPaint fPaint; | 467 SkPaint fPaint; |
466 | 468 |
467 typedef SkDrawCommand INHERITED; | 469 typedef SkDrawCommand INHERITED; |
468 }; | 470 }; |
469 | 471 |
470 class SkDrawRRectCommand : public SkDrawCommand { | 472 class SkDrawRRectCommand : public SkDrawCommand { |
471 public: | 473 public: |
472 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); | 474 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); |
473 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 475 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
474 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 476 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
475 private: | 477 private: |
476 SkRRect fRRect; | 478 SkRRect fRRect; |
477 SkPaint fPaint; | 479 SkPaint fPaint; |
478 | 480 |
479 typedef SkDrawCommand INHERITED; | 481 typedef SkDrawCommand INHERITED; |
480 }; | 482 }; |
481 | 483 |
482 class SkDrawDRRectCommand : public SkDrawCommand { | 484 class SkDrawDRRectCommand : public SkDrawCommand { |
483 public: | 485 public: |
484 SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, | 486 SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, |
485 const SkPaint& paint); | 487 const SkPaint& paint); |
486 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 488 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
487 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 489 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
488 private: | 490 private: |
489 SkRRect fOuter; | 491 SkRRect fOuter; |
490 SkRRect fInner; | 492 SkRRect fInner; |
491 SkPaint fPaint; | 493 SkPaint fPaint; |
492 | 494 |
493 typedef SkDrawCommand INHERITED; | 495 typedef SkDrawCommand INHERITED; |
494 }; | 496 }; |
495 | 497 |
496 class SkDrawSpriteCommand : public SkDrawCommand { | 498 class SkDrawSpriteCommand : public SkDrawCommand { |
497 public: | 499 public: |
498 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint
* paint); | 500 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint
* paint); |
499 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 501 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
500 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 502 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
501 private: | 503 private: |
502 SkBitmap fBitmap; | 504 SkBitmap fBitmap; |
503 int fLeft; | 505 int fLeft; |
504 int fTop; | 506 int fTop; |
505 SkPaint fPaint; | 507 SkPaint fPaint; |
506 SkPaint* fPaintPtr; | 508 SkPaint* fPaintPtr; |
507 | 509 |
508 typedef SkDrawCommand INHERITED; | 510 typedef SkDrawCommand INHERITED; |
509 }; | 511 }; |
510 | 512 |
511 class SkDrawVerticesCommand : public SkDrawCommand { | 513 class SkDrawVerticesCommand : public SkDrawCommand { |
512 public: | 514 public: |
513 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, | 515 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, |
514 const SkPoint vertices[], const SkPoint texs[], | 516 const SkPoint vertices[], const SkPoint texs[], |
515 const SkColor colors[], SkXfermode* xfermode, | 517 const SkColor colors[], SkXfermode* xfermode, |
516 const uint16_t indices[], int indexCount, | 518 const uint16_t indices[], int indexCount, |
517 const SkPaint& paint); | 519 const SkPaint& paint); |
518 virtual ~SkDrawVerticesCommand(); | 520 virtual ~SkDrawVerticesCommand(); |
519 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 521 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
520 private: | 522 private: |
521 SkCanvas::VertexMode fVmode; | 523 SkCanvas::VertexMode fVmode; |
522 int fVertexCount; | 524 int fVertexCount; |
523 SkPoint* fVertices; | 525 SkPoint* fVertices; |
524 SkPoint* fTexs; | 526 SkPoint* fTexs; |
525 SkColor* fColors; | 527 SkColor* fColors; |
526 SkXfermode* fXfermode; | 528 SkXfermode* fXfermode; |
527 uint16_t* fIndices; | 529 uint16_t* fIndices; |
528 int fIndexCount; | 530 int fIndexCount; |
529 SkPaint fPaint; | 531 SkPaint fPaint; |
530 | 532 |
531 typedef SkDrawCommand INHERITED; | 533 typedef SkDrawCommand INHERITED; |
532 }; | 534 }; |
533 | 535 |
534 class SkRotateCommand : public SkDrawCommand { | 536 class SkRotateCommand : public SkDrawCommand { |
535 public: | 537 public: |
536 SkRotateCommand(SkScalar degrees); | 538 SkRotateCommand(SkScalar degrees); |
537 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 539 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
538 private: | 540 private: |
539 SkScalar fDegrees; | 541 SkScalar fDegrees; |
540 | 542 |
541 typedef SkDrawCommand INHERITED; | 543 typedef SkDrawCommand INHERITED; |
542 }; | 544 }; |
543 | 545 |
544 class SkSaveCommand : public SkDrawCommand { | 546 class SkSaveCommand : public SkDrawCommand { |
545 public: | 547 public: |
546 SkSaveCommand(); | 548 SkSaveCommand(); |
547 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 549 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
548 virtual void trackSaveState(int* state) SK_OVERRIDE; | 550 virtual void trackSaveState(int* state) SK_OVERRIDE; |
549 virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; } | 551 virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; } |
550 private: | 552 private: |
551 typedef SkDrawCommand INHERITED; | 553 typedef SkDrawCommand INHERITED; |
552 }; | 554 }; |
553 | 555 |
554 class SkSaveLayerCommand : public SkDrawCommand { | 556 class SkSaveLayerCommand : public SkDrawCommand { |
555 public: | 557 public: |
556 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, | 558 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, |
557 SkCanvas::SaveFlags flags); | 559 SkCanvas::SaveFlags flags); |
558 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 560 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
559 virtual void vizExecute(SkCanvas* canvas) const SK_OVERRIDE; | 561 virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE; |
560 virtual void trackSaveState(int* state) SK_OVERRIDE; | 562 virtual void trackSaveState(int* state) SK_OVERRIDE; |
561 virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; } | 563 virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; } |
562 virtual void setActive(bool active) SK_OVERRIDE { fActive = active; } | 564 virtual void setActive(bool active) SK_OVERRIDE { fActive = active; } |
563 virtual bool active() const SK_OVERRIDE { return fActive; } | 565 virtual bool active() const SK_OVERRIDE { return fActive; } |
564 | 566 |
565 const SkPaint* paint() const { return fPaintPtr; } | 567 const SkPaint* paint() const { return fPaintPtr; } |
566 | 568 |
567 private: | 569 private: |
568 SkRect fBounds; | 570 SkRect fBounds; |
569 SkPaint fPaint; | 571 SkPaint fPaint; |
570 SkPaint* fPaintPtr; | 572 SkPaint* fPaintPtr; |
571 SkCanvas::SaveFlags fFlags; | 573 SkCanvas::SaveFlags fFlags; |
572 | 574 |
573 bool fActive; | 575 bool fActive; |
574 | 576 |
575 typedef SkDrawCommand INHERITED; | 577 typedef SkDrawCommand INHERITED; |
576 }; | 578 }; |
577 | 579 |
578 class SkScaleCommand : public SkDrawCommand { | 580 class SkScaleCommand : public SkDrawCommand { |
579 public: | 581 public: |
580 SkScaleCommand(SkScalar sx, SkScalar sy); | 582 SkScaleCommand(SkScalar sx, SkScalar sy); |
581 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 583 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
582 | 584 |
583 SkScalar x() const { return fSx; } | 585 SkScalar x() const { return fSx; } |
584 SkScalar y() const { return fSy; } | 586 SkScalar y() const { return fSy; } |
585 | 587 |
586 private: | 588 private: |
587 SkScalar fSx; | 589 SkScalar fSx; |
588 SkScalar fSy; | 590 SkScalar fSy; |
589 | 591 |
590 typedef SkDrawCommand INHERITED; | 592 typedef SkDrawCommand INHERITED; |
591 }; | 593 }; |
592 | 594 |
593 class SkSetMatrixCommand : public SkDrawCommand { | 595 class SkSetMatrixCommand : public SkDrawCommand { |
594 public: | 596 public: |
595 SkSetMatrixCommand(const SkMatrix& matrix); | 597 SkSetMatrixCommand(const SkMatrix& matrix); |
596 virtual void setUserMatrix(const SkMatrix&) SK_OVERRIDE; | 598 virtual void setUserMatrix(const SkMatrix&) SK_OVERRIDE; |
597 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 599 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
598 private: | 600 private: |
599 SkMatrix fUserMatrix; | 601 SkMatrix fUserMatrix; |
600 SkMatrix fMatrix; | 602 SkMatrix fMatrix; |
601 | 603 |
602 typedef SkDrawCommand INHERITED; | 604 typedef SkDrawCommand INHERITED; |
603 }; | 605 }; |
604 | 606 |
605 class SkSkewCommand : public SkDrawCommand { | 607 class SkSkewCommand : public SkDrawCommand { |
606 public: | 608 public: |
607 SkSkewCommand(SkScalar sx, SkScalar sy); | 609 SkSkewCommand(SkScalar sx, SkScalar sy); |
608 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 610 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
609 private: | 611 private: |
610 SkScalar fSx; | 612 SkScalar fSx; |
611 SkScalar fSy; | 613 SkScalar fSy; |
612 | 614 |
613 typedef SkDrawCommand INHERITED; | 615 typedef SkDrawCommand INHERITED; |
614 }; | 616 }; |
615 | 617 |
616 class SkTranslateCommand : public SkDrawCommand { | 618 class SkTranslateCommand : public SkDrawCommand { |
617 public: | 619 public: |
618 SkTranslateCommand(SkScalar dx, SkScalar dy); | 620 SkTranslateCommand(SkScalar dx, SkScalar dy); |
619 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 621 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
620 | 622 |
621 SkScalar x() const { return fDx; } | 623 SkScalar x() const { return fDx; } |
622 SkScalar y() const { return fDy; } | 624 SkScalar y() const { return fDy; } |
623 | 625 |
624 private: | 626 private: |
625 SkScalar fDx; | 627 SkScalar fDx; |
626 SkScalar fDy; | 628 SkScalar fDy; |
627 | 629 |
628 typedef SkDrawCommand INHERITED; | 630 typedef SkDrawCommand INHERITED; |
629 }; | 631 }; |
630 | 632 |
631 class SkPushCullCommand : public SkDrawCommand { | 633 class SkPushCullCommand : public SkDrawCommand { |
632 public: | 634 public: |
633 SkPushCullCommand(const SkRect&); | 635 SkPushCullCommand(const SkRect&); |
634 virtual void execute(SkCanvas*) const SK_OVERRIDE; | 636 virtual void execute(SkCanvas*) SK_OVERRIDE; |
635 virtual void vizExecute(SkCanvas* canvas) const SK_OVERRIDE; | 637 virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE; |
636 virtual Action action() const { return kPushCull_Action; } | 638 virtual Action action() const { return kPushCull_Action; } |
637 virtual void setActive(bool active) { fActive = active; } | 639 virtual void setActive(bool active) { fActive = active; } |
638 virtual bool active() const { return fActive; } | 640 virtual bool active() const { return fActive; } |
639 private: | 641 private: |
640 SkRect fCullRect; | 642 SkRect fCullRect; |
641 bool fActive; | 643 bool fActive; |
642 | 644 |
643 typedef SkDrawCommand INHERITED; | 645 typedef SkDrawCommand INHERITED; |
644 }; | 646 }; |
645 | 647 |
646 class SkPopCullCommand : public SkDrawCommand { | 648 class SkPopCullCommand : public SkDrawCommand { |
647 public: | 649 public: |
648 SkPopCullCommand(); | 650 SkPopCullCommand(); |
649 virtual void execute(SkCanvas* canvas) const SK_OVERRIDE; | 651 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
650 virtual Action action() const { return kPopCull_Action; } | 652 virtual Action action() const { return kPopCull_Action; } |
651 private: | 653 private: |
652 typedef SkDrawCommand INHERITED; | 654 typedef SkDrawCommand INHERITED; |
653 }; | 655 }; |
654 | 656 |
655 #endif | 657 #endif |
OLD | NEW |