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_ |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
47 static const char* GetCommandString(DrawType type); | 47 static const char* GetCommandString(DrawType type); |
48 | 48 |
49 protected: | 49 protected: |
50 DrawType fDrawType; | 50 DrawType fDrawType; |
51 SkTDArray<SkString*> fInfo; | 51 SkTDArray<SkString*> fInfo; |
52 | 52 |
53 private: | 53 private: |
54 bool fVisible; | 54 bool fVisible; |
55 }; | 55 }; |
56 | 56 |
57 class Restore : public SkDrawCommand { | 57 class SkRestoreCommand : public SkDrawCommand { |
58 public: | 58 public: |
59 Restore(); | 59 SkRestoreCommand(); |
60 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 60 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
61 virtual void trackSaveState(int* state) SK_OVERRIDE; | 61 virtual void trackSaveState(int* state) SK_OVERRIDE; |
62 | 62 |
63 private: | 63 private: |
64 typedef SkDrawCommand INHERITED; | 64 typedef SkDrawCommand INHERITED; |
65 }; | 65 }; |
66 | 66 |
67 class Clear : public SkDrawCommand { | 67 class SkClearCommand : public SkDrawCommand { |
68 public: | 68 public: |
69 Clear(SkColor color); | 69 SkClearCommand(SkColor color); |
70 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 70 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
71 private: | 71 private: |
72 SkColor fColor; | 72 SkColor fColor; |
73 | 73 |
74 typedef SkDrawCommand INHERITED; | 74 typedef SkDrawCommand INHERITED; |
75 }; | 75 }; |
76 | 76 |
77 class ClipPath : public SkDrawCommand { | 77 class SkClipPathCommand : public SkDrawCommand { |
78 public: | 78 public: |
79 ClipPath(const SkPath& path, SkRegion::Op op, bool doAA); | 79 SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA); |
80 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 80 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
81 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 81 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
82 private: | 82 private: |
83 SkPath fPath; | 83 SkPath fPath; |
84 SkRegion::Op fOp; | 84 SkRegion::Op fOp; |
85 bool fDoAA; | 85 bool fDoAA; |
86 | 86 |
87 typedef SkDrawCommand INHERITED; | 87 typedef SkDrawCommand INHERITED; |
88 }; | 88 }; |
89 | 89 |
90 class ClipRegion : public SkDrawCommand { | 90 class SkClipRegionCommand : public SkDrawCommand { |
91 public: | 91 public: |
92 ClipRegion(const SkRegion& region, SkRegion::Op op); | 92 SkClipRegionCommand(const SkRegion& region, SkRegion::Op op); |
93 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 93 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
94 private: | 94 private: |
95 SkRegion fRegion; | 95 SkRegion fRegion; |
96 SkRegion::Op fOp; | 96 SkRegion::Op fOp; |
97 | 97 |
98 typedef SkDrawCommand INHERITED; | 98 typedef SkDrawCommand INHERITED; |
99 }; | 99 }; |
100 | 100 |
101 class ClipRect : public SkDrawCommand { | 101 class SkClipRectCommand : public SkDrawCommand { |
102 public: | 102 public: |
103 ClipRect(const SkRect& rect, SkRegion::Op op, bool doAA); | 103 SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA); |
104 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 104 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
105 | 105 |
106 const SkRect& rect() const { return fRect; } | 106 const SkRect& rect() const { return fRect; } |
107 SkRegion::Op op() const { return fOp; } | 107 SkRegion::Op op() const { return fOp; } |
108 bool doAA() const { return fDoAA; } | 108 bool doAA() const { return fDoAA; } |
109 | 109 |
110 private: | 110 private: |
111 SkRect fRect; | 111 SkRect fRect; |
112 SkRegion::Op fOp; | 112 SkRegion::Op fOp; |
113 bool fDoAA; | 113 bool fDoAA; |
114 | 114 |
115 typedef SkDrawCommand INHERITED; | 115 typedef SkDrawCommand INHERITED; |
116 }; | 116 }; |
117 | 117 |
118 class ClipRRect : public SkDrawCommand { | 118 class SkClipRRectCommand : public SkDrawCommand { |
119 public: | 119 public: |
120 ClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA); | 120 SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA); |
121 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 121 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
122 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 122 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
123 | 123 |
124 const SkRRect& rrect() const { return fRRect; } | 124 const SkRRect& rrect() const { return fRRect; } |
125 SkRegion::Op op() const { return fOp; } | 125 SkRegion::Op op() const { return fOp; } |
126 bool doAA() const { return fDoAA; } | 126 bool doAA() const { return fDoAA; } |
127 | 127 |
128 private: | 128 private: |
129 SkRRect fRRect; | 129 SkRRect fRRect; |
130 SkRegion::Op fOp; | 130 SkRegion::Op fOp; |
131 bool fDoAA; | 131 bool fDoAA; |
132 | 132 |
133 typedef SkDrawCommand INHERITED; | 133 typedef SkDrawCommand INHERITED; |
134 }; | 134 }; |
135 | 135 |
136 class Concat : public SkDrawCommand { | 136 class SkConcatCommand : public SkDrawCommand { |
137 public: | 137 public: |
138 Concat(const SkMatrix& matrix); | 138 SkConcatCommand(const SkMatrix& matrix); |
139 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 139 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
140 private: | 140 private: |
141 SkMatrix fMatrix; | 141 SkMatrix fMatrix; |
142 | 142 |
143 typedef SkDrawCommand INHERITED; | 143 typedef SkDrawCommand INHERITED; |
144 }; | 144 }; |
145 | 145 |
146 class DrawBitmap : public SkDrawCommand { | 146 class SkDrawBitmapCommand : public SkDrawCommand { |
147 public: | 147 public: |
148 DrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, | 148 SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, |
149 const SkPaint* paint); | 149 const SkPaint* paint); |
150 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 150 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
151 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 151 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
152 private: | 152 private: |
153 SkBitmap fBitmap; | 153 SkBitmap fBitmap; |
154 SkScalar fLeft; | 154 SkScalar fLeft; |
155 SkScalar fTop; | 155 SkScalar fTop; |
156 SkPaint fPaint; | 156 SkPaint fPaint; |
157 SkPaint* fPaintPtr; | 157 SkPaint* fPaintPtr; |
158 | 158 |
159 typedef SkDrawCommand INHERITED; | 159 typedef SkDrawCommand INHERITED; |
160 }; | 160 }; |
161 | 161 |
162 class DrawBitmapMatrix : public SkDrawCommand { | 162 class SkDrawBitmapMatrixCommand : public SkDrawCommand { |
163 public: | 163 public: |
164 DrawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix, | 164 SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix, |
165 const SkPaint* paint); | 165 const SkPaint* paint); |
166 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 166 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
167 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 167 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
168 private: | 168 private: |
169 SkBitmap fBitmap; | 169 SkBitmap fBitmap; |
170 SkMatrix fMatrix; | 170 SkMatrix fMatrix; |
171 SkPaint fPaint; | 171 SkPaint fPaint; |
172 SkPaint* fPaintPtr; | 172 SkPaint* fPaintPtr; |
173 | 173 |
174 typedef SkDrawCommand INHERITED; | 174 typedef SkDrawCommand INHERITED; |
175 }; | 175 }; |
176 | 176 |
177 class DrawBitmapNine : public SkDrawCommand { | 177 class SkDrawBitmapNineCommand : public SkDrawCommand { |
178 public: | 178 public: |
179 DrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, | 179 SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, |
180 const SkRect& dst, const SkPaint* paint); | 180 const SkRect& dst, const SkPaint* paint); |
181 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 181 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
182 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 182 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
183 private: | 183 private: |
184 SkBitmap fBitmap; | 184 SkBitmap fBitmap; |
185 SkIRect fCenter; | 185 SkIRect fCenter; |
186 SkRect fDst; | 186 SkRect fDst; |
187 SkPaint fPaint; | 187 SkPaint fPaint; |
188 SkPaint* fPaintPtr; | 188 SkPaint* fPaintPtr; |
189 | 189 |
190 typedef SkDrawCommand INHERITED; | 190 typedef SkDrawCommand INHERITED; |
191 }; | 191 }; |
192 | 192 |
193 class DrawBitmapRect : public SkDrawCommand { | 193 class SkDrawBitmapRectCommand : public SkDrawCommand { |
194 public: | 194 public: |
195 DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, | 195 SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, |
196 const SkRect& dst, const SkPaint* paint); | 196 const SkRect& dst, const SkPaint* paint); |
197 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 197 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
198 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 198 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
199 | 199 |
200 const SkBitmap& bitmap() const { return fBitmap; } | 200 const SkBitmap& bitmap() const { return fBitmap; } |
201 | 201 |
202 // The non-const 'paint' method allows modification of this object's | 202 // The non-const 'paint' method allows modification of this object's |
203 // SkPaint. For this reason the ctor and setPaint method make a local copy. | 203 // SkPaint. For this reason the ctor and setPaint method make a local copy. |
204 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid | 204 // The 'fPaintPtr' member acts a signal that the local SkPaint is valid |
205 // (since only an SkPaint* is passed into the ctor). | 205 // (since only an SkPaint* is passed into the ctor). |
(...skipping 11 matching lines...) Expand all Loading... |
217 private: | 217 private: |
218 SkBitmap fBitmap; | 218 SkBitmap fBitmap; |
219 SkRect fSrc; | 219 SkRect fSrc; |
220 SkRect fDst; | 220 SkRect fDst; |
221 SkPaint fPaint; | 221 SkPaint fPaint; |
222 SkPaint* fPaintPtr; | 222 SkPaint* fPaintPtr; |
223 | 223 |
224 typedef SkDrawCommand INHERITED; | 224 typedef SkDrawCommand INHERITED; |
225 }; | 225 }; |
226 | 226 |
227 class DrawData : public SkDrawCommand { | 227 class SkDrawDataCommand : public SkDrawCommand { |
228 public: | 228 public: |
229 DrawData(const void* data, size_t length); | 229 SkDrawDataCommand(const void* data, size_t length); |
230 virtual ~DrawData() { delete [] fData; } | 230 virtual ~SkDrawDataCommand() { delete [] fData; } |
231 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 231 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
232 private: | 232 private: |
233 char* fData; | 233 char* fData; |
234 size_t fLength; | 234 size_t fLength; |
235 | 235 |
236 typedef SkDrawCommand INHERITED; | 236 typedef SkDrawCommand INHERITED; |
237 }; | 237 }; |
238 | 238 |
239 class BeginCommentGroup : public SkDrawCommand { | 239 class SkBeginCommentGroupCommand : public SkDrawCommand { |
240 public: | 240 public: |
241 BeginCommentGroup(const char* description); | 241 SkBeginCommentGroupCommand(const char* description); |
242 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { | 242 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { |
243 canvas->beginCommentGroup(fDescription.c_str()); | 243 canvas->beginCommentGroup(fDescription.c_str()); |
244 }; | 244 }; |
245 private: | 245 private: |
246 SkString fDescription; | 246 SkString fDescription; |
247 | 247 |
248 typedef SkDrawCommand INHERITED; | 248 typedef SkDrawCommand INHERITED; |
249 }; | 249 }; |
250 | 250 |
251 class Comment : public SkDrawCommand { | 251 class SkCommentCommand : public SkDrawCommand { |
252 public: | 252 public: |
253 Comment(const char* kywd, const char* value); | 253 SkCommentCommand(const char* kywd, const char* value); |
254 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { | 254 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { |
255 canvas->addComment(fKywd.c_str(), fValue.c_str()); | 255 canvas->addComment(fKywd.c_str(), fValue.c_str()); |
256 }; | 256 }; |
257 private: | 257 private: |
258 SkString fKywd; | 258 SkString fKywd; |
259 SkString fValue; | 259 SkString fValue; |
260 | 260 |
261 typedef SkDrawCommand INHERITED; | 261 typedef SkDrawCommand INHERITED; |
262 }; | 262 }; |
263 | 263 |
264 class EndCommentGroup : public SkDrawCommand { | 264 class SkEndCommentGroupCommand : public SkDrawCommand { |
265 public: | 265 public: |
266 EndCommentGroup(); | 266 SkEndCommentGroupCommand(); |
267 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { | 267 virtual void execute(SkCanvas* canvas) SK_OVERRIDE { |
268 canvas->endCommentGroup(); | 268 canvas->endCommentGroup(); |
269 }; | 269 }; |
270 private: | 270 private: |
271 typedef SkDrawCommand INHERITED; | 271 typedef SkDrawCommand INHERITED; |
272 }; | 272 }; |
273 | 273 |
274 class DrawOval : public SkDrawCommand { | 274 class SkDrawOvalCommand : public SkDrawCommand { |
275 public: | 275 public: |
276 DrawOval(const SkRect& oval, const SkPaint& paint); | 276 SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint); |
277 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 277 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
278 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 278 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
279 private: | 279 private: |
280 SkRect fOval; | 280 SkRect fOval; |
281 SkPaint fPaint; | 281 SkPaint fPaint; |
282 | 282 |
283 typedef SkDrawCommand INHERITED; | 283 typedef SkDrawCommand INHERITED; |
284 }; | 284 }; |
285 | 285 |
286 class DrawPaint : public SkDrawCommand { | 286 class SkDrawPaintCommand : public SkDrawCommand { |
287 public: | 287 public: |
288 DrawPaint(const SkPaint& paint); | 288 SkDrawPaintCommand(const SkPaint& paint); |
289 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 289 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
290 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 290 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
291 private: | 291 private: |
292 SkPaint fPaint; | 292 SkPaint fPaint; |
293 | 293 |
294 typedef SkDrawCommand INHERITED; | 294 typedef SkDrawCommand INHERITED; |
295 }; | 295 }; |
296 | 296 |
297 class DrawPath : public SkDrawCommand { | 297 class SkDrawPathCommand : public SkDrawCommand { |
298 public: | 298 public: |
299 DrawPath(const SkPath& path, const SkPaint& paint); | 299 SkDrawPathCommand(const SkPath& path, const SkPaint& paint); |
300 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 300 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
301 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 301 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
302 | 302 |
303 private: | 303 private: |
304 SkPath fPath; | 304 SkPath fPath; |
305 SkPaint fPaint; | 305 SkPaint fPaint; |
306 | 306 |
307 typedef SkDrawCommand INHERITED; | 307 typedef SkDrawCommand INHERITED; |
308 }; | 308 }; |
309 | 309 |
310 class DrawPicture : public SkDrawCommand { | 310 class SkDrawPictureCommand : public SkDrawCommand { |
311 public: | 311 public: |
312 DrawPicture(SkPicture& picture); | 312 SkDrawPictureCommand(SkPicture& picture); |
313 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 313 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
314 private: | 314 private: |
315 SkPicture fPicture; | 315 SkPicture fPicture; |
316 | 316 |
317 typedef SkDrawCommand INHERITED; | 317 typedef SkDrawCommand INHERITED; |
318 }; | 318 }; |
319 | 319 |
320 class DrawPoints : public SkDrawCommand { | 320 class SkDrawPointsCommand : public SkDrawCommand { |
321 public: | 321 public: |
322 DrawPoints(SkCanvas::PointMode mode, size_t count, const SkPoint pts[], | 322 SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pt
s[], |
323 const SkPaint& paint); | 323 const SkPaint& paint); |
324 virtual ~DrawPoints() { delete [] fPts; } | 324 virtual ~SkDrawPointsCommand() { delete [] fPts; } |
325 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 325 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
326 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 326 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
327 private: | 327 private: |
328 SkCanvas::PointMode fMode; | 328 SkCanvas::PointMode fMode; |
329 size_t fCount; | 329 size_t fCount; |
330 SkPoint* fPts; | 330 SkPoint* fPts; |
331 SkPaint fPaint; | 331 SkPaint fPaint; |
332 | 332 |
333 typedef SkDrawCommand INHERITED; | 333 typedef SkDrawCommand INHERITED; |
334 }; | 334 }; |
335 | 335 |
336 /* TODO(chudy): DrawText is a predefined macro and was breaking something | 336 class SkDrawTextCommand : public SkDrawCommand { |
337 * in the windows build of the debugger. | |
338 */ | |
339 class DrawTextC : public SkDrawCommand { | |
340 public: | 337 public: |
341 DrawTextC(const void* text, size_t byteLength, SkScalar x, SkScalar y, | 338 SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar
y, |
342 const SkPaint& paint); | 339 const SkPaint& paint); |
343 virtual ~DrawTextC() { delete [] fText; } | 340 virtual ~SkDrawTextCommand() { delete [] fText; } |
344 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 341 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
345 private: | 342 private: |
346 char* fText; | 343 char* fText; |
347 size_t fByteLength; | 344 size_t fByteLength; |
348 SkScalar fX; | 345 SkScalar fX; |
349 SkScalar fY; | 346 SkScalar fY; |
350 SkPaint fPaint; | 347 SkPaint fPaint; |
351 | 348 |
352 typedef SkDrawCommand INHERITED; | 349 typedef SkDrawCommand INHERITED; |
353 }; | 350 }; |
354 | 351 |
355 class DrawPosText : public SkDrawCommand { | 352 class SkDrawPosTextCommand : public SkDrawCommand { |
356 public: | 353 public: |
357 DrawPosText(const void* text, size_t byteLength, const SkPoint pos[], | 354 SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[
], |
358 const SkPaint& paint); | 355 const SkPaint& paint); |
359 virtual ~DrawPosText() { delete [] fPos; delete [] fText; } | 356 virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; } |
360 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 357 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
361 private: | 358 private: |
362 char* fText; | 359 char* fText; |
363 size_t fByteLength; | 360 size_t fByteLength; |
364 SkPoint* fPos; | 361 SkPoint* fPos; |
365 SkPaint fPaint; | 362 SkPaint fPaint; |
366 | 363 |
367 typedef SkDrawCommand INHERITED; | 364 typedef SkDrawCommand INHERITED; |
368 }; | 365 }; |
369 | 366 |
370 class DrawTextOnPath : public SkDrawCommand { | 367 class SkDrawTextOnPathCommand : public SkDrawCommand { |
371 public: | 368 public: |
372 DrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, | 369 SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& p
ath, |
373 const SkMatrix* matrix, const SkPaint& paint); | 370 const SkMatrix* matrix, const SkPaint& paint); |
374 virtual ~DrawTextOnPath() { delete [] fText; } | 371 virtual ~SkDrawTextOnPathCommand() { delete [] fText; } |
375 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 372 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
376 private: | 373 private: |
377 char* fText; | 374 char* fText; |
378 size_t fByteLength; | 375 size_t fByteLength; |
379 SkPath fPath; | 376 SkPath fPath; |
380 SkMatrix fMatrix; | 377 SkMatrix fMatrix; |
381 SkPaint fPaint; | 378 SkPaint fPaint; |
382 | 379 |
383 typedef SkDrawCommand INHERITED; | 380 typedef SkDrawCommand INHERITED; |
384 }; | 381 }; |
385 | 382 |
386 class DrawPosTextH : public SkDrawCommand { | 383 class SkDrawPosTextHCommand : public SkDrawCommand { |
387 public: | 384 public: |
388 DrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], | 385 SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xp
os[], |
389 SkScalar constY, const SkPaint& paint); | 386 SkScalar constY, const SkPaint& paint); |
390 virtual ~DrawPosTextH() { delete [] fXpos; delete [] fText; } | 387 virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; } |
391 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 388 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
392 private: | 389 private: |
393 SkScalar* fXpos; | 390 SkScalar* fXpos; |
394 char* fText; | 391 char* fText; |
395 size_t fByteLength; | 392 size_t fByteLength; |
396 SkScalar fConstY; | 393 SkScalar fConstY; |
397 SkPaint fPaint; | 394 SkPaint fPaint; |
398 | 395 |
399 typedef SkDrawCommand INHERITED; | 396 typedef SkDrawCommand INHERITED; |
400 }; | 397 }; |
401 | 398 |
402 class DrawRectC : public SkDrawCommand { | 399 class SkDrawRectCommand : public SkDrawCommand { |
403 public: | 400 public: |
404 DrawRectC(const SkRect& rect, const SkPaint& paint); | 401 SkDrawRectCommand(const SkRect& rect, const SkPaint& paint); |
405 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 402 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
406 | 403 |
407 const SkRect& rect() const { return fRect; } | 404 const SkRect& rect() const { return fRect; } |
408 const SkPaint& paint() const { return fPaint; } | 405 const SkPaint& paint() const { return fPaint; } |
409 private: | 406 private: |
410 SkRect fRect; | 407 SkRect fRect; |
411 SkPaint fPaint; | 408 SkPaint fPaint; |
412 | 409 |
413 typedef SkDrawCommand INHERITED; | 410 typedef SkDrawCommand INHERITED; |
414 }; | 411 }; |
415 | 412 |
416 class DrawRRect : public SkDrawCommand { | 413 class SkDrawRRectCommand : public SkDrawCommand { |
417 public: | 414 public: |
418 DrawRRect(const SkRRect& rrect, const SkPaint& paint); | 415 SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint); |
419 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 416 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
420 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 417 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
421 private: | 418 private: |
422 SkRRect fRRect; | 419 SkRRect fRRect; |
423 SkPaint fPaint; | 420 SkPaint fPaint; |
424 | 421 |
425 typedef SkDrawCommand INHERITED; | 422 typedef SkDrawCommand INHERITED; |
426 }; | 423 }; |
427 | 424 |
428 class DrawSprite : public SkDrawCommand { | 425 class SkDrawSpriteCommand : public SkDrawCommand { |
429 public: | 426 public: |
430 DrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint); | 427 SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint
* paint); |
431 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 428 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
432 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; | 429 virtual bool render(SkCanvas* canvas) const SK_OVERRIDE; |
433 private: | 430 private: |
434 SkBitmap fBitmap; | 431 SkBitmap fBitmap; |
435 int fLeft; | 432 int fLeft; |
436 int fTop; | 433 int fTop; |
437 SkPaint fPaint; | 434 SkPaint fPaint; |
438 SkPaint* fPaintPtr; | 435 SkPaint* fPaintPtr; |
439 | 436 |
440 typedef SkDrawCommand INHERITED; | 437 typedef SkDrawCommand INHERITED; |
441 }; | 438 }; |
442 | 439 |
443 class DrawVertices : public SkDrawCommand { | 440 class SkDrawVerticesCommand : public SkDrawCommand { |
444 public: | 441 public: |
445 DrawVertices(SkCanvas::VertexMode vmode, int vertexCount, | 442 SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, |
446 const SkPoint vertices[], const SkPoint texs[], | 443 const SkPoint vertices[], const SkPoint texs[], |
447 const SkColor colors[], SkXfermode* xfermode, | 444 const SkColor colors[], SkXfermode* xfermode, |
448 const uint16_t indices[], int indexCount, | 445 const uint16_t indices[], int indexCount, |
449 const SkPaint& paint); | 446 const SkPaint& paint); |
450 virtual ~DrawVertices(); | 447 virtual ~SkDrawVerticesCommand(); |
451 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 448 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
452 private: | 449 private: |
453 SkCanvas::VertexMode fVmode; | 450 SkCanvas::VertexMode fVmode; |
454 int fVertexCount; | 451 int fVertexCount; |
455 SkPoint* fVertices; | 452 SkPoint* fVertices; |
456 SkPoint* fTexs; | 453 SkPoint* fTexs; |
457 SkColor* fColors; | 454 SkColor* fColors; |
458 SkXfermode* fXfermode; | 455 SkXfermode* fXfermode; |
459 uint16_t* fIndices; | 456 uint16_t* fIndices; |
460 int fIndexCount; | 457 int fIndexCount; |
461 SkPaint fPaint; | 458 SkPaint fPaint; |
462 | 459 |
463 typedef SkDrawCommand INHERITED; | 460 typedef SkDrawCommand INHERITED; |
464 }; | 461 }; |
465 | 462 |
466 class Rotate : public SkDrawCommand { | 463 class SkRotateCommand : public SkDrawCommand { |
467 public: | 464 public: |
468 Rotate(SkScalar degrees); | 465 SkRotateCommand(SkScalar degrees); |
469 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 466 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
470 private: | 467 private: |
471 SkScalar fDegrees; | 468 SkScalar fDegrees; |
472 | 469 |
473 typedef SkDrawCommand INHERITED; | 470 typedef SkDrawCommand INHERITED; |
474 }; | 471 }; |
475 | 472 |
476 class Save : public SkDrawCommand { | 473 class SkSaveCommand : public SkDrawCommand { |
477 public: | 474 public: |
478 Save(SkCanvas::SaveFlags flags); | 475 SkSaveCommand(SkCanvas::SaveFlags flags); |
479 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 476 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
480 virtual void trackSaveState(int* state) SK_OVERRIDE; | 477 virtual void trackSaveState(int* state) SK_OVERRIDE; |
481 private: | 478 private: |
482 SkCanvas::SaveFlags fFlags; | 479 SkCanvas::SaveFlags fFlags; |
483 | 480 |
484 typedef SkDrawCommand INHERITED; | 481 typedef SkDrawCommand INHERITED; |
485 }; | 482 }; |
486 | 483 |
487 class SaveLayer : public SkDrawCommand { | 484 class SkSaveLayerCommand : public SkDrawCommand { |
488 public: | 485 public: |
489 SaveLayer(const SkRect* bounds, const SkPaint* paint, | 486 SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, |
490 SkCanvas::SaveFlags flags); | 487 SkCanvas::SaveFlags flags); |
491 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 488 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
492 virtual void trackSaveState(int* state) SK_OVERRIDE; | 489 virtual void trackSaveState(int* state) SK_OVERRIDE; |
493 | 490 |
494 const SkPaint* paint() const { return fPaintPtr; } | 491 const SkPaint* paint() const { return fPaintPtr; } |
495 | 492 |
496 private: | 493 private: |
497 SkRect fBounds; | 494 SkRect fBounds; |
498 SkPaint fPaint; | 495 SkPaint fPaint; |
499 SkPaint* fPaintPtr; | 496 SkPaint* fPaintPtr; |
500 SkCanvas::SaveFlags fFlags; | 497 SkCanvas::SaveFlags fFlags; |
501 | 498 |
502 typedef SkDrawCommand INHERITED; | 499 typedef SkDrawCommand INHERITED; |
503 }; | 500 }; |
504 | 501 |
505 class Scale : public SkDrawCommand { | 502 class SkScaleCommand : public SkDrawCommand { |
506 public: | 503 public: |
507 Scale(SkScalar sx, SkScalar sy); | 504 SkScaleCommand(SkScalar sx, SkScalar sy); |
508 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 505 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
509 | 506 |
510 SkScalar x() const { return fSx; } | 507 SkScalar x() const { return fSx; } |
511 SkScalar y() const { return fSy; } | 508 SkScalar y() const { return fSy; } |
512 | 509 |
513 private: | 510 private: |
514 SkScalar fSx; | 511 SkScalar fSx; |
515 SkScalar fSy; | 512 SkScalar fSy; |
516 | 513 |
517 typedef SkDrawCommand INHERITED; | 514 typedef SkDrawCommand INHERITED; |
518 }; | 515 }; |
519 | 516 |
520 class SetMatrix : public SkDrawCommand { | 517 class SkSetMatrixCommand : public SkDrawCommand { |
521 public: | 518 public: |
522 SetMatrix(const SkMatrix& matrix); | 519 SkSetMatrixCommand(const SkMatrix& matrix); |
523 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 520 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
524 private: | 521 private: |
525 SkMatrix fMatrix; | 522 SkMatrix fMatrix; |
526 | 523 |
527 typedef SkDrawCommand INHERITED; | 524 typedef SkDrawCommand INHERITED; |
528 }; | 525 }; |
529 | 526 |
530 class Skew : public SkDrawCommand { | 527 class SkSkewCommand : public SkDrawCommand { |
531 public: | 528 public: |
532 Skew(SkScalar sx, SkScalar sy); | 529 SkSkewCommand(SkScalar sx, SkScalar sy); |
533 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 530 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
534 private: | 531 private: |
535 SkScalar fSx; | 532 SkScalar fSx; |
536 SkScalar fSy; | 533 SkScalar fSy; |
537 | 534 |
538 typedef SkDrawCommand INHERITED; | 535 typedef SkDrawCommand INHERITED; |
539 }; | 536 }; |
540 | 537 |
541 class Translate : public SkDrawCommand { | 538 class SkTranslateCommand : public SkDrawCommand { |
542 public: | 539 public: |
543 Translate(SkScalar dx, SkScalar dy); | 540 SkTranslateCommand(SkScalar dx, SkScalar dy); |
544 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; | 541 virtual void execute(SkCanvas* canvas) SK_OVERRIDE; |
545 | 542 |
546 SkScalar x() const { return fDx; } | 543 SkScalar x() const { return fDx; } |
547 SkScalar y() const { return fDy; } | 544 SkScalar y() const { return fDy; } |
548 | 545 |
549 private: | 546 private: |
550 SkScalar fDx; | 547 SkScalar fDx; |
551 SkScalar fDy; | 548 SkScalar fDy; |
552 | 549 |
553 typedef SkDrawCommand INHERITED; | 550 typedef SkDrawCommand INHERITED; |
554 }; | 551 }; |
555 | 552 |
556 #endif | 553 #endif |
OLD | NEW |