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 | 9 |
10 #include "SkDrawCommand.h" | 10 #include "SkDrawCommand.h" |
11 #include "SkObjectParser.h" | 11 #include "SkObjectParser.h" |
12 | 12 |
13 #include "SkTextBlob.h" | 13 #include "SkTextBlob.h" |
14 | 14 |
15 // TODO(chudy): Refactor into non subclass model. | 15 // TODO(chudy): Refactor into non subclass model. |
16 | 16 |
17 SkDrawCommand::SkDrawCommand(DrawType type) | 17 SkDrawCommand::SkDrawCommand(DrawType type) |
18 : fDrawType(type) | 18 : fDrawType(type) |
19 , fOffset(0) | 19 , fOffset(0) |
20 , fVisible(true) { | 20 , fVisible(true) { |
21 } | 21 } |
22 | 22 |
| 23 SkDrawCommand::SkDrawCommand() { |
| 24 fOffset = 0; |
| 25 fVisible = true; |
| 26 } |
| 27 |
23 SkDrawCommand::~SkDrawCommand() { | 28 SkDrawCommand::~SkDrawCommand() { |
24 fInfo.deleteAll(); | 29 fInfo.deleteAll(); |
25 } | 30 } |
26 | 31 |
27 const char* SkDrawCommand::GetCommandString(DrawType type) { | 32 const char* SkDrawCommand::GetCommandString(DrawType type) { |
28 switch (type) { | 33 switch (type) { |
29 case UNUSED: SkDEBUGFAIL("DrawType UNUSED\n"); break; | 34 case UNUSED: SkDEBUGFAIL("DrawType UNUSED\n"); break; |
30 case DRAW_CLEAR: return "Clear"; | 35 case DRAW_CLEAR: return "Clear"; |
31 case CLIP_PATH: return "Clip Path"; | 36 case CLIP_PATH: return "Clip Path"; |
32 case CLIP_REGION: return "Clip Region"; | 37 case CLIP_REGION: return "Clip Region"; |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
69 case POP_CULL: return "PopCull"; | 74 case POP_CULL: return "PopCull"; |
70 default: | 75 default: |
71 SkDebugf("DrawType error 0x%08x\n", type); | 76 SkDebugf("DrawType error 0x%08x\n", type); |
72 SkASSERT(0); | 77 SkASSERT(0); |
73 break; | 78 break; |
74 } | 79 } |
75 SkDEBUGFAIL("DrawType UNUSED\n"); | 80 SkDEBUGFAIL("DrawType UNUSED\n"); |
76 return NULL; | 81 return NULL; |
77 } | 82 } |
78 | 83 |
79 SkString SkDrawCommand::toString() const { | 84 SkString SkDrawCommand::toString() { |
80 return SkString(GetCommandString(fDrawType)); | 85 return SkString(GetCommandString(fDrawType)); |
81 } | 86 } |
82 | 87 |
83 SkClearCommand::SkClearCommand(SkColor color) : INHERITED(DRAW_CLEAR) { | 88 SkClearCommand::SkClearCommand(SkColor color) : INHERITED(DRAW_CLEAR) { |
84 fColor = color; | 89 fColor = color; |
85 fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); | 90 fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); |
86 } | 91 } |
87 | 92 |
88 void SkClearCommand::execute(SkCanvas* canvas) const { | 93 void SkClearCommand::execute(SkCanvas* canvas) { |
89 canvas->clear(fColor); | 94 canvas->clear(fColor); |
90 } | 95 } |
91 | 96 |
92 namespace { | 97 namespace { |
93 | 98 |
94 void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) { | 99 void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) { |
95 const SkISize& size = canvas->getDeviceSize(); | 100 const SkISize& size = canvas->getDeviceSize(); |
96 | 101 |
97 static const SkScalar kInsetFrac = 0.9f; // Leave a border around object | 102 static const SkScalar kInsetFrac = 0.9f; // Leave a border around object |
98 | 103 |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
195 : INHERITED(CLIP_PATH) { | 200 : INHERITED(CLIP_PATH) { |
196 fPath = path; | 201 fPath = path; |
197 fOp = op; | 202 fOp = op; |
198 fDoAA = doAA; | 203 fDoAA = doAA; |
199 | 204 |
200 fInfo.push(SkObjectParser::PathToString(path)); | 205 fInfo.push(SkObjectParser::PathToString(path)); |
201 fInfo.push(SkObjectParser::RegionOpToString(op)); | 206 fInfo.push(SkObjectParser::RegionOpToString(op)); |
202 fInfo.push(SkObjectParser::BoolToString(doAA)); | 207 fInfo.push(SkObjectParser::BoolToString(doAA)); |
203 } | 208 } |
204 | 209 |
205 void SkClipPathCommand::execute(SkCanvas* canvas) const { | 210 void SkClipPathCommand::execute(SkCanvas* canvas) { |
206 canvas->clipPath(fPath, fOp, fDoAA); | 211 canvas->clipPath(fPath, fOp, fDoAA); |
207 } | 212 } |
208 | 213 |
209 bool SkClipPathCommand::render(SkCanvas* canvas) const { | 214 bool SkClipPathCommand::render(SkCanvas* canvas) const { |
210 render_path(canvas, fPath); | 215 render_path(canvas, fPath); |
211 return true; | 216 return true; |
212 } | 217 } |
213 | 218 |
214 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op
) | 219 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op
) |
215 : INHERITED(CLIP_REGION) { | 220 : INHERITED(CLIP_REGION) { |
216 fRegion = region; | 221 fRegion = region; |
217 fOp = op; | 222 fOp = op; |
218 | 223 |
219 fInfo.push(SkObjectParser::RegionToString(region)); | 224 fInfo.push(SkObjectParser::RegionToString(region)); |
220 fInfo.push(SkObjectParser::RegionOpToString(op)); | 225 fInfo.push(SkObjectParser::RegionOpToString(op)); |
221 } | 226 } |
222 | 227 |
223 void SkClipRegionCommand::execute(SkCanvas* canvas) const { | 228 void SkClipRegionCommand::execute(SkCanvas* canvas) { |
224 canvas->clipRegion(fRegion, fOp); | 229 canvas->clipRegion(fRegion, fOp); |
225 } | 230 } |
226 | 231 |
227 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool d
oAA) | 232 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool d
oAA) |
228 : INHERITED(CLIP_RECT) { | 233 : INHERITED(CLIP_RECT) { |
229 fRect = rect; | 234 fRect = rect; |
230 fOp = op; | 235 fOp = op; |
231 fDoAA = doAA; | 236 fDoAA = doAA; |
232 | 237 |
233 fInfo.push(SkObjectParser::RectToString(rect)); | 238 fInfo.push(SkObjectParser::RectToString(rect)); |
234 fInfo.push(SkObjectParser::RegionOpToString(op)); | 239 fInfo.push(SkObjectParser::RegionOpToString(op)); |
235 fInfo.push(SkObjectParser::BoolToString(doAA)); | 240 fInfo.push(SkObjectParser::BoolToString(doAA)); |
236 } | 241 } |
237 | 242 |
238 void SkClipRectCommand::execute(SkCanvas* canvas) const { | 243 void SkClipRectCommand::execute(SkCanvas* canvas) { |
239 canvas->clipRect(fRect, fOp, fDoAA); | 244 canvas->clipRect(fRect, fOp, fDoAA); |
240 } | 245 } |
241 | 246 |
242 SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bo
ol doAA) | 247 SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bo
ol doAA) |
243 : INHERITED(CLIP_RRECT) { | 248 : INHERITED(CLIP_RRECT) { |
244 fRRect = rrect; | 249 fRRect = rrect; |
245 fOp = op; | 250 fOp = op; |
246 fDoAA = doAA; | 251 fDoAA = doAA; |
247 | 252 |
248 fInfo.push(SkObjectParser::RRectToString(rrect)); | 253 fInfo.push(SkObjectParser::RRectToString(rrect)); |
249 fInfo.push(SkObjectParser::RegionOpToString(op)); | 254 fInfo.push(SkObjectParser::RegionOpToString(op)); |
250 fInfo.push(SkObjectParser::BoolToString(doAA)); | 255 fInfo.push(SkObjectParser::BoolToString(doAA)); |
251 } | 256 } |
252 | 257 |
253 void SkClipRRectCommand::execute(SkCanvas* canvas) const { | 258 void SkClipRRectCommand::execute(SkCanvas* canvas) { |
254 canvas->clipRRect(fRRect, fOp, fDoAA); | 259 canvas->clipRRect(fRRect, fOp, fDoAA); |
255 } | 260 } |
256 | 261 |
257 bool SkClipRRectCommand::render(SkCanvas* canvas) const { | 262 bool SkClipRRectCommand::render(SkCanvas* canvas) const { |
258 render_rrect(canvas, fRRect); | 263 render_rrect(canvas, fRRect); |
259 return true; | 264 return true; |
260 } | 265 } |
261 | 266 |
262 SkConcatCommand::SkConcatCommand(const SkMatrix& matrix) | 267 SkConcatCommand::SkConcatCommand(const SkMatrix& matrix) |
263 : INHERITED(CONCAT) { | 268 : INHERITED(CONCAT) { |
264 fMatrix = matrix; | 269 fMatrix = matrix; |
265 | 270 |
266 fInfo.push(SkObjectParser::MatrixToString(matrix)); | 271 fInfo.push(SkObjectParser::MatrixToString(matrix)); |
267 } | 272 } |
268 | 273 |
269 void SkConcatCommand::execute(SkCanvas* canvas) const { | 274 void SkConcatCommand::execute(SkCanvas* canvas) { |
270 canvas->concat(fMatrix); | 275 canvas->concat(fMatrix); |
271 } | 276 } |
272 | 277 |
273 SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left,
SkScalar top, | 278 SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left,
SkScalar top, |
274 const SkPaint* paint) | 279 const SkPaint* paint) |
275 : INHERITED(DRAW_BITMAP) { | 280 : INHERITED(DRAW_BITMAP) { |
276 fBitmap = bitmap; | 281 fBitmap = bitmap; |
277 fLeft = left; | 282 fLeft = left; |
278 fTop = top; | 283 fTop = top; |
279 if (paint) { | 284 if (paint) { |
280 fPaint = *paint; | 285 fPaint = *paint; |
281 fPaintPtr = &fPaint; | 286 fPaintPtr = &fPaint; |
282 } else { | 287 } else { |
283 fPaintPtr = NULL; | 288 fPaintPtr = NULL; |
284 } | 289 } |
285 | 290 |
286 fInfo.push(SkObjectParser::BitmapToString(bitmap)); | 291 fInfo.push(SkObjectParser::BitmapToString(bitmap)); |
287 fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: ")); | 292 fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: ")); |
288 fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: ")); | 293 fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: ")); |
289 if (paint) { | 294 if (paint) { |
290 fInfo.push(SkObjectParser::PaintToString(*paint)); | 295 fInfo.push(SkObjectParser::PaintToString(*paint)); |
291 } | 296 } |
292 } | 297 } |
293 | 298 |
294 void SkDrawBitmapCommand::execute(SkCanvas* canvas) const { | 299 void SkDrawBitmapCommand::execute(SkCanvas* canvas) { |
295 canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr); | 300 canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr); |
296 } | 301 } |
297 | 302 |
298 bool SkDrawBitmapCommand::render(SkCanvas* canvas) const { | 303 bool SkDrawBitmapCommand::render(SkCanvas* canvas) const { |
299 render_bitmap(canvas, fBitmap); | 304 render_bitmap(canvas, fBitmap); |
300 return true; | 305 return true; |
301 } | 306 } |
302 | 307 |
303 SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, | 308 SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, |
304 const SkMatrix& matrix, | 309 const SkMatrix& matrix, |
305 const SkPaint* paint) | 310 const SkPaint* paint) |
306 : INHERITED(DRAW_BITMAP_MATRIX) { | 311 : INHERITED(DRAW_BITMAP_MATRIX) { |
307 fBitmap = bitmap; | 312 fBitmap = bitmap; |
308 fMatrix = matrix; | 313 fMatrix = matrix; |
309 if (paint) { | 314 if (paint) { |
310 fPaint = *paint; | 315 fPaint = *paint; |
311 fPaintPtr = &fPaint; | 316 fPaintPtr = &fPaint; |
312 } else { | 317 } else { |
313 fPaintPtr = NULL; | 318 fPaintPtr = NULL; |
314 } | 319 } |
315 | 320 |
316 fInfo.push(SkObjectParser::BitmapToString(bitmap)); | 321 fInfo.push(SkObjectParser::BitmapToString(bitmap)); |
317 fInfo.push(SkObjectParser::MatrixToString(matrix)); | 322 fInfo.push(SkObjectParser::MatrixToString(matrix)); |
318 if (paint) { | 323 if (paint) { |
319 fInfo.push(SkObjectParser::PaintToString(*paint)); | 324 fInfo.push(SkObjectParser::PaintToString(*paint)); |
320 } | 325 } |
321 } | 326 } |
322 | 327 |
323 void SkDrawBitmapMatrixCommand::execute(SkCanvas* canvas) const { | 328 void SkDrawBitmapMatrixCommand::execute(SkCanvas* canvas) { |
324 canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr); | 329 canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr); |
325 } | 330 } |
326 | 331 |
327 bool SkDrawBitmapMatrixCommand::render(SkCanvas* canvas) const { | 332 bool SkDrawBitmapMatrixCommand::render(SkCanvas* canvas) const { |
328 render_bitmap(canvas, fBitmap); | 333 render_bitmap(canvas, fBitmap); |
329 return true; | 334 return true; |
330 } | 335 } |
331 | 336 |
332 SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const S
kIRect& center, | 337 SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const S
kIRect& center, |
333 const SkRect& dst, const SkPain
t* paint) | 338 const SkRect& dst, const SkPain
t* paint) |
334 : INHERITED(DRAW_BITMAP_NINE) { | 339 : INHERITED(DRAW_BITMAP_NINE) { |
335 fBitmap = bitmap; | 340 fBitmap = bitmap; |
336 fCenter = center; | 341 fCenter = center; |
337 fDst = dst; | 342 fDst = dst; |
338 if (paint) { | 343 if (paint) { |
339 fPaint = *paint; | 344 fPaint = *paint; |
340 fPaintPtr = &fPaint; | 345 fPaintPtr = &fPaint; |
341 } else { | 346 } else { |
342 fPaintPtr = NULL; | 347 fPaintPtr = NULL; |
343 } | 348 } |
344 | 349 |
345 fInfo.push(SkObjectParser::BitmapToString(bitmap)); | 350 fInfo.push(SkObjectParser::BitmapToString(bitmap)); |
346 fInfo.push(SkObjectParser::IRectToString(center)); | 351 fInfo.push(SkObjectParser::IRectToString(center)); |
347 fInfo.push(SkObjectParser::RectToString(dst, "Dst: ")); | 352 fInfo.push(SkObjectParser::RectToString(dst, "Dst: ")); |
348 if (paint) { | 353 if (paint) { |
349 fInfo.push(SkObjectParser::PaintToString(*paint)); | 354 fInfo.push(SkObjectParser::PaintToString(*paint)); |
350 } | 355 } |
351 } | 356 } |
352 | 357 |
353 void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) const { | 358 void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) { |
354 canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr); | 359 canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr); |
355 } | 360 } |
356 | 361 |
357 bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const { | 362 bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const { |
358 render_bitmap(canvas, fBitmap); | 363 render_bitmap(canvas, fBitmap); |
359 return true; | 364 return true; |
360 } | 365 } |
361 | 366 |
362 SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const S
kRect* src, | 367 SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const S
kRect* src, |
363 const SkRect& dst, const SkPain
t* paint, | 368 const SkRect& dst, const SkPain
t* paint, |
(...skipping 19 matching lines...) Expand all Loading... |
383 if (src) { | 388 if (src) { |
384 fInfo.push(SkObjectParser::RectToString(*src, "Src: ")); | 389 fInfo.push(SkObjectParser::RectToString(*src, "Src: ")); |
385 } | 390 } |
386 fInfo.push(SkObjectParser::RectToString(dst, "Dst: ")); | 391 fInfo.push(SkObjectParser::RectToString(dst, "Dst: ")); |
387 if (paint) { | 392 if (paint) { |
388 fInfo.push(SkObjectParser::PaintToString(*paint)); | 393 fInfo.push(SkObjectParser::PaintToString(*paint)); |
389 } | 394 } |
390 fInfo.push(SkObjectParser::IntToString(fFlags, "Flags: ")); | 395 fInfo.push(SkObjectParser::IntToString(fFlags, "Flags: ")); |
391 } | 396 } |
392 | 397 |
393 void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) const { | 398 void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) { |
394 canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr, fFla
gs); | 399 canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr, fFla
gs); |
395 } | 400 } |
396 | 401 |
397 bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const { | 402 bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const { |
398 render_bitmap(canvas, fBitmap, this->srcRect()); | 403 render_bitmap(canvas, fBitmap, this->srcRect()); |
399 return true; | 404 return true; |
400 } | 405 } |
401 | 406 |
402 SkDrawDataCommand::SkDrawDataCommand(const void* data, size_t length) | 407 SkDrawDataCommand::SkDrawDataCommand(const void* data, size_t length) |
403 : INHERITED(DRAW_DATA) { | 408 : INHERITED(DRAW_DATA) { |
404 fData = new char[length]; | 409 fData = new char[length]; |
405 memcpy(fData, data, length); | 410 memcpy(fData, data, length); |
406 fLength = length; | 411 fLength = length; |
407 | 412 |
408 // TODO: add display of actual data? | 413 // TODO: add display of actual data? |
409 SkString* str = new SkString; | 414 SkString* str = new SkString; |
410 str->appendf("length: %d", (int) length); | 415 str->appendf("length: %d", (int) length); |
411 fInfo.push(str); | 416 fInfo.push(str); |
412 } | 417 } |
413 | 418 |
414 void SkDrawDataCommand::execute(SkCanvas* canvas) const { | 419 void SkDrawDataCommand::execute(SkCanvas* canvas) { |
415 canvas->drawData(fData, fLength); | 420 canvas->drawData(fData, fLength); |
416 } | 421 } |
417 | 422 |
418 SkBeginCommentGroupCommand::SkBeginCommentGroupCommand(const char* description) | 423 SkBeginCommentGroupCommand::SkBeginCommentGroupCommand(const char* description) |
419 : INHERITED(BEGIN_COMMENT_GROUP) | 424 : INHERITED(BEGIN_COMMENT_GROUP) |
420 , fDescription(description) { | 425 , fDescription(description) { |
421 SkString* temp = new SkString; | 426 SkString* temp = new SkString; |
422 temp->appendf("Description: %s", description); | 427 temp->appendf("Description: %s", description); |
423 fInfo.push(temp); | 428 fInfo.push(temp); |
424 } | 429 } |
(...skipping 13 matching lines...) Expand all Loading... |
438 | 443 |
439 SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) | 444 SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) |
440 : INHERITED(DRAW_OVAL) { | 445 : INHERITED(DRAW_OVAL) { |
441 fOval = oval; | 446 fOval = oval; |
442 fPaint = paint; | 447 fPaint = paint; |
443 | 448 |
444 fInfo.push(SkObjectParser::RectToString(oval)); | 449 fInfo.push(SkObjectParser::RectToString(oval)); |
445 fInfo.push(SkObjectParser::PaintToString(paint)); | 450 fInfo.push(SkObjectParser::PaintToString(paint)); |
446 } | 451 } |
447 | 452 |
448 void SkDrawOvalCommand::execute(SkCanvas* canvas) const { | 453 void SkDrawOvalCommand::execute(SkCanvas* canvas) { |
449 canvas->drawOval(fOval, fPaint); | 454 canvas->drawOval(fOval, fPaint); |
450 } | 455 } |
451 | 456 |
452 bool SkDrawOvalCommand::render(SkCanvas* canvas) const { | 457 bool SkDrawOvalCommand::render(SkCanvas* canvas) const { |
453 canvas->clear(0xFFFFFFFF); | 458 canvas->clear(0xFFFFFFFF); |
454 canvas->save(); | 459 canvas->save(); |
455 | 460 |
456 xlate_and_scale_to_bounds(canvas, fOval); | 461 xlate_and_scale_to_bounds(canvas, fOval); |
457 | 462 |
458 SkPaint p; | 463 SkPaint p; |
459 p.setColor(SK_ColorBLACK); | 464 p.setColor(SK_ColorBLACK); |
460 p.setStyle(SkPaint::kStroke_Style); | 465 p.setStyle(SkPaint::kStroke_Style); |
461 | 466 |
462 canvas->drawOval(fOval, p); | 467 canvas->drawOval(fOval, p); |
463 canvas->restore(); | 468 canvas->restore(); |
464 | 469 |
465 return true; | 470 return true; |
466 } | 471 } |
467 | 472 |
468 SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) | 473 SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) |
469 : INHERITED(DRAW_PAINT) { | 474 : INHERITED(DRAW_PAINT) { |
470 fPaint = paint; | 475 fPaint = paint; |
471 | 476 |
472 fInfo.push(SkObjectParser::PaintToString(paint)); | 477 fInfo.push(SkObjectParser::PaintToString(paint)); |
473 } | 478 } |
474 | 479 |
475 void SkDrawPaintCommand::execute(SkCanvas* canvas) const { | 480 void SkDrawPaintCommand::execute(SkCanvas* canvas) { |
476 canvas->drawPaint(fPaint); | 481 canvas->drawPaint(fPaint); |
477 } | 482 } |
478 | 483 |
479 bool SkDrawPaintCommand::render(SkCanvas* canvas) const { | 484 bool SkDrawPaintCommand::render(SkCanvas* canvas) const { |
480 canvas->clear(0xFFFFFFFF); | 485 canvas->clear(0xFFFFFFFF); |
481 canvas->drawPaint(fPaint); | 486 canvas->drawPaint(fPaint); |
482 return true; | 487 return true; |
483 } | 488 } |
484 | 489 |
485 SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) | 490 SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) |
486 : INHERITED(DRAW_PATH) { | 491 : INHERITED(DRAW_PATH) { |
487 fPath = path; | 492 fPath = path; |
488 fPaint = paint; | 493 fPaint = paint; |
489 | 494 |
490 fInfo.push(SkObjectParser::PathToString(path)); | 495 fInfo.push(SkObjectParser::PathToString(path)); |
491 fInfo.push(SkObjectParser::PaintToString(paint)); | 496 fInfo.push(SkObjectParser::PaintToString(paint)); |
492 } | 497 } |
493 | 498 |
494 void SkDrawPathCommand::execute(SkCanvas* canvas) const { | 499 void SkDrawPathCommand::execute(SkCanvas* canvas) { |
495 canvas->drawPath(fPath, fPaint); | 500 canvas->drawPath(fPath, fPaint); |
496 } | 501 } |
497 | 502 |
498 bool SkDrawPathCommand::render(SkCanvas* canvas) const { | 503 bool SkDrawPathCommand::render(SkCanvas* canvas) const { |
499 render_path(canvas, fPath); | 504 render_path(canvas, fPath); |
500 return true; | 505 return true; |
501 } | 506 } |
502 | 507 |
503 SkDrawPictureCommand::SkDrawPictureCommand(const SkPicture* picture, | 508 SkDrawPictureCommand::SkDrawPictureCommand(const SkPicture* picture, |
504 const SkMatrix* matrix, | 509 const SkMatrix* matrix, |
(...skipping 18 matching lines...) Expand all Loading... |
523 picture->cullRect().fRight, picture->cullRect().fBottom); | 528 picture->cullRect().fRight, picture->cullRect().fBottom); |
524 fInfo.push(temp); | 529 fInfo.push(temp); |
525 if (matrix) { | 530 if (matrix) { |
526 fInfo.push(SkObjectParser::MatrixToString(*matrix)); | 531 fInfo.push(SkObjectParser::MatrixToString(*matrix)); |
527 } | 532 } |
528 if (paint) { | 533 if (paint) { |
529 fInfo.push(SkObjectParser::PaintToString(*paint)); | 534 fInfo.push(SkObjectParser::PaintToString(*paint)); |
530 } | 535 } |
531 } | 536 } |
532 | 537 |
533 void SkDrawPictureCommand::execute(SkCanvas* canvas) const { | 538 void SkDrawPictureCommand::execute(SkCanvas* canvas) { |
534 canvas->drawPicture(fPicture, fMatrixPtr, fPaintPtr); | 539 canvas->drawPicture(fPicture, fMatrixPtr, fPaintPtr); |
535 } | 540 } |
536 | 541 |
537 bool SkDrawPictureCommand::render(SkCanvas* canvas) const { | 542 bool SkDrawPictureCommand::render(SkCanvas* canvas) const { |
538 canvas->clear(0xFFFFFFFF); | 543 canvas->clear(0xFFFFFFFF); |
539 canvas->save(); | 544 canvas->save(); |
540 | 545 |
541 xlate_and_scale_to_bounds(canvas, fPicture->cullRect()); | 546 xlate_and_scale_to_bounds(canvas, fPicture->cullRect()); |
542 | 547 |
543 canvas->drawPicture(fPicture.get()); | 548 canvas->drawPicture(fPicture.get()); |
(...skipping 12 matching lines...) Expand all Loading... |
556 memcpy(fPts, pts, count * sizeof(SkPoint)); | 561 memcpy(fPts, pts, count * sizeof(SkPoint)); |
557 fPaint = paint; | 562 fPaint = paint; |
558 | 563 |
559 fInfo.push(SkObjectParser::PointsToString(pts, count)); | 564 fInfo.push(SkObjectParser::PointsToString(pts, count)); |
560 fInfo.push(SkObjectParser::ScalarToString(SkIntToScalar((unsigned int)count)
, | 565 fInfo.push(SkObjectParser::ScalarToString(SkIntToScalar((unsigned int)count)
, |
561 "Points: ")); | 566 "Points: ")); |
562 fInfo.push(SkObjectParser::PointModeToString(mode)); | 567 fInfo.push(SkObjectParser::PointModeToString(mode)); |
563 fInfo.push(SkObjectParser::PaintToString(paint)); | 568 fInfo.push(SkObjectParser::PaintToString(paint)); |
564 } | 569 } |
565 | 570 |
566 void SkDrawPointsCommand::execute(SkCanvas* canvas) const { | 571 void SkDrawPointsCommand::execute(SkCanvas* canvas) { |
567 canvas->drawPoints(fMode, fCount, fPts, fPaint); | 572 canvas->drawPoints(fMode, fCount, fPts, fPaint); |
568 } | 573 } |
569 | 574 |
570 bool SkDrawPointsCommand::render(SkCanvas* canvas) const { | 575 bool SkDrawPointsCommand::render(SkCanvas* canvas) const { |
571 canvas->clear(0xFFFFFFFF); | 576 canvas->clear(0xFFFFFFFF); |
572 canvas->save(); | 577 canvas->save(); |
573 | 578 |
574 SkRect bounds; | 579 SkRect bounds; |
575 | 580 |
576 bounds.setEmpty(); | 581 bounds.setEmpty(); |
(...skipping 26 matching lines...) Expand all Loading... |
603 memcpy(fPos, pos, numPts * sizeof(SkPoint)); | 608 memcpy(fPos, pos, numPts * sizeof(SkPoint)); |
604 | 609 |
605 fPaint = paint; | 610 fPaint = paint; |
606 | 611 |
607 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); | 612 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); |
608 // TODO(chudy): Test that this works. | 613 // TODO(chudy): Test that this works. |
609 fInfo.push(SkObjectParser::PointsToString(pos, 1)); | 614 fInfo.push(SkObjectParser::PointsToString(pos, 1)); |
610 fInfo.push(SkObjectParser::PaintToString(paint)); | 615 fInfo.push(SkObjectParser::PaintToString(paint)); |
611 } | 616 } |
612 | 617 |
613 void SkDrawPosTextCommand::execute(SkCanvas* canvas) const { | 618 void SkDrawPosTextCommand::execute(SkCanvas* canvas) { |
614 canvas->drawPosText(fText, fByteLength, fPos, fPaint); | 619 canvas->drawPosText(fText, fByteLength, fPos, fPaint); |
615 } | 620 } |
616 | 621 |
617 | 622 |
618 SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength
, | 623 SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength
, |
619 const SkScalar xpos[], SkScalar con
stY, | 624 const SkScalar xpos[], SkScalar con
stY, |
620 const SkPaint& paint) | 625 const SkPaint& paint) |
621 : INHERITED(DRAW_POS_TEXT_H) { | 626 : INHERITED(DRAW_POS_TEXT_H) { |
622 size_t numPts = paint.countText(text, byteLength); | 627 size_t numPts = paint.countText(text, byteLength); |
623 | 628 |
624 fText = new char[byteLength]; | 629 fText = new char[byteLength]; |
625 memcpy(fText, text, byteLength); | 630 memcpy(fText, text, byteLength); |
626 fByteLength = byteLength; | 631 fByteLength = byteLength; |
627 | 632 |
628 fXpos = new SkScalar[numPts]; | 633 fXpos = new SkScalar[numPts]; |
629 memcpy(fXpos, xpos, numPts * sizeof(SkScalar)); | 634 memcpy(fXpos, xpos, numPts * sizeof(SkScalar)); |
630 | 635 |
631 fConstY = constY; | 636 fConstY = constY; |
632 fPaint = paint; | 637 fPaint = paint; |
633 | 638 |
634 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); | 639 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); |
635 fInfo.push(SkObjectParser::ScalarToString(xpos[0], "XPOS: ")); | 640 fInfo.push(SkObjectParser::ScalarToString(xpos[0], "XPOS: ")); |
636 fInfo.push(SkObjectParser::ScalarToString(constY, "SkScalar constY: ")); | 641 fInfo.push(SkObjectParser::ScalarToString(constY, "SkScalar constY: ")); |
637 fInfo.push(SkObjectParser::PaintToString(paint)); | 642 fInfo.push(SkObjectParser::PaintToString(paint)); |
638 } | 643 } |
639 | 644 |
640 void SkDrawPosTextHCommand::execute(SkCanvas* canvas) const { | 645 void SkDrawPosTextHCommand::execute(SkCanvas* canvas) { |
641 canvas->drawPosTextH(fText, fByteLength, fXpos, fConstY, fPaint); | 646 canvas->drawPosTextH(fText, fByteLength, fXpos, fConstY, fPaint); |
642 } | 647 } |
643 | 648 |
644 SkDrawTextBlobCommand::SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x,
SkScalar y, | 649 SkDrawTextBlobCommand::SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x,
SkScalar y, |
645 const SkPaint& paint) | 650 const SkPaint& paint) |
646 : INHERITED(DRAW_TEXT_BLOB) | 651 : INHERITED(DRAW_TEXT_BLOB) |
647 , fBlob(blob) | 652 , fBlob(blob) |
648 , fXPos(x) | 653 , fXPos(x) |
649 , fYPos(y) | 654 , fYPos(y) |
650 , fPaint(paint) { | 655 , fPaint(paint) { |
651 | 656 |
652 blob->ref(); | 657 blob->ref(); |
653 | 658 |
654 // FIXME: push blob info | 659 // FIXME: push blob info |
655 fInfo.push(SkObjectParser::ScalarToString(x, "XPOS: ")); | 660 fInfo.push(SkObjectParser::ScalarToString(x, "XPOS: ")); |
656 fInfo.push(SkObjectParser::ScalarToString(x, "YPOS: ")); | 661 fInfo.push(SkObjectParser::ScalarToString(x, "YPOS: ")); |
657 fInfo.push(SkObjectParser::PaintToString(paint)); | 662 fInfo.push(SkObjectParser::PaintToString(paint)); |
658 } | 663 } |
659 | 664 |
660 void SkDrawTextBlobCommand::execute(SkCanvas* canvas) const { | 665 void SkDrawTextBlobCommand::execute(SkCanvas* canvas) { |
661 canvas->drawTextBlob(fBlob, fXPos, fYPos, fPaint); | 666 canvas->drawTextBlob(fBlob, fXPos, fYPos, fPaint); |
662 } | 667 } |
663 | 668 |
664 bool SkDrawTextBlobCommand::render(SkCanvas* canvas) const { | 669 bool SkDrawTextBlobCommand::render(SkCanvas* canvas) const { |
665 canvas->clear(SK_ColorWHITE); | 670 canvas->clear(SK_ColorWHITE); |
666 canvas->save(); | 671 canvas->save(); |
667 | 672 |
668 SkRect bounds = fBlob->bounds().makeOffset(fXPos, fYPos); | 673 SkRect bounds = fBlob->bounds().makeOffset(fXPos, fYPos); |
669 xlate_and_scale_to_bounds(canvas, bounds); | 674 xlate_and_scale_to_bounds(canvas, bounds); |
670 | 675 |
671 canvas->drawTextBlob(fBlob.get(), fXPos, fYPos, fPaint); | 676 canvas->drawTextBlob(fBlob.get(), fXPos, fYPos, fPaint); |
672 | 677 |
673 canvas->restore(); | 678 canvas->restore(); |
674 | 679 |
675 return true; | 680 return true; |
676 } | 681 } |
677 | 682 |
678 SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint) | 683 SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint) |
679 : INHERITED(DRAW_RECT) { | 684 : INHERITED(DRAW_RECT) { |
680 fRect = rect; | 685 fRect = rect; |
681 fPaint = paint; | 686 fPaint = paint; |
682 | 687 |
683 fInfo.push(SkObjectParser::RectToString(rect)); | 688 fInfo.push(SkObjectParser::RectToString(rect)); |
684 fInfo.push(SkObjectParser::PaintToString(paint)); | 689 fInfo.push(SkObjectParser::PaintToString(paint)); |
685 } | 690 } |
686 | 691 |
687 void SkDrawRectCommand::execute(SkCanvas* canvas) const { | 692 void SkDrawRectCommand::execute(SkCanvas* canvas) { |
688 canvas->drawRect(fRect, fPaint); | 693 canvas->drawRect(fRect, fPaint); |
689 } | 694 } |
690 | 695 |
691 SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& pain
t) | 696 SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& pain
t) |
692 : INHERITED(DRAW_RRECT) { | 697 : INHERITED(DRAW_RRECT) { |
693 fRRect = rrect; | 698 fRRect = rrect; |
694 fPaint = paint; | 699 fPaint = paint; |
695 | 700 |
696 fInfo.push(SkObjectParser::RRectToString(rrect)); | 701 fInfo.push(SkObjectParser::RRectToString(rrect)); |
697 fInfo.push(SkObjectParser::PaintToString(paint)); | 702 fInfo.push(SkObjectParser::PaintToString(paint)); |
698 } | 703 } |
699 | 704 |
700 void SkDrawRRectCommand::execute(SkCanvas* canvas) const { | 705 void SkDrawRRectCommand::execute(SkCanvas* canvas) { |
701 canvas->drawRRect(fRRect, fPaint); | 706 canvas->drawRRect(fRRect, fPaint); |
702 } | 707 } |
703 | 708 |
704 bool SkDrawRRectCommand::render(SkCanvas* canvas) const { | 709 bool SkDrawRRectCommand::render(SkCanvas* canvas) const { |
705 render_rrect(canvas, fRRect); | 710 render_rrect(canvas, fRRect); |
706 return true; | 711 return true; |
707 } | 712 } |
708 | 713 |
709 SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer, | 714 SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer, |
710 const SkRRect& inner, | 715 const SkRRect& inner, |
711 const SkPaint& paint) | 716 const SkPaint& paint) |
712 : INHERITED(DRAW_DRRECT) { | 717 : INHERITED(DRAW_DRRECT) { |
713 fOuter = outer; | 718 fOuter = outer; |
714 fInner = inner; | 719 fInner = inner; |
715 fPaint = paint; | 720 fPaint = paint; |
716 | 721 |
717 fInfo.push(SkObjectParser::RRectToString(outer)); | 722 fInfo.push(SkObjectParser::RRectToString(outer)); |
718 fInfo.push(SkObjectParser::RRectToString(inner)); | 723 fInfo.push(SkObjectParser::RRectToString(inner)); |
719 fInfo.push(SkObjectParser::PaintToString(paint)); | 724 fInfo.push(SkObjectParser::PaintToString(paint)); |
720 } | 725 } |
721 | 726 |
722 void SkDrawDRRectCommand::execute(SkCanvas* canvas) const { | 727 void SkDrawDRRectCommand::execute(SkCanvas* canvas) { |
723 canvas->drawDRRect(fOuter, fInner, fPaint); | 728 canvas->drawDRRect(fOuter, fInner, fPaint); |
724 } | 729 } |
725 | 730 |
726 bool SkDrawDRRectCommand::render(SkCanvas* canvas) const { | 731 bool SkDrawDRRectCommand::render(SkCanvas* canvas) const { |
727 render_drrect(canvas, fOuter, fInner); | 732 render_drrect(canvas, fOuter, fInner); |
728 return true; | 733 return true; |
729 } | 734 } |
730 | 735 |
731 SkDrawSpriteCommand::SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int t
op, | 736 SkDrawSpriteCommand::SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int t
op, |
732 const SkPaint* paint) | 737 const SkPaint* paint) |
733 : INHERITED(DRAW_SPRITE) { | 738 : INHERITED(DRAW_SPRITE) { |
734 fBitmap = bitmap; | 739 fBitmap = bitmap; |
735 fLeft = left; | 740 fLeft = left; |
736 fTop = top; | 741 fTop = top; |
737 if (paint) { | 742 if (paint) { |
738 fPaint = *paint; | 743 fPaint = *paint; |
739 fPaintPtr = &fPaint; | 744 fPaintPtr = &fPaint; |
740 } else { | 745 } else { |
741 fPaintPtr = NULL; | 746 fPaintPtr = NULL; |
742 } | 747 } |
743 | 748 |
744 fInfo.push(SkObjectParser::BitmapToString(bitmap)); | 749 fInfo.push(SkObjectParser::BitmapToString(bitmap)); |
745 fInfo.push(SkObjectParser::IntToString(left, "Left: ")); | 750 fInfo.push(SkObjectParser::IntToString(left, "Left: ")); |
746 fInfo.push(SkObjectParser::IntToString(top, "Top: ")); | 751 fInfo.push(SkObjectParser::IntToString(top, "Top: ")); |
747 if (paint) { | 752 if (paint) { |
748 fInfo.push(SkObjectParser::PaintToString(*paint)); | 753 fInfo.push(SkObjectParser::PaintToString(*paint)); |
749 } | 754 } |
750 } | 755 } |
751 | 756 |
752 void SkDrawSpriteCommand::execute(SkCanvas* canvas) const { | 757 void SkDrawSpriteCommand::execute(SkCanvas* canvas) { |
753 canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr); | 758 canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr); |
754 } | 759 } |
755 | 760 |
756 bool SkDrawSpriteCommand::render(SkCanvas* canvas) const { | 761 bool SkDrawSpriteCommand::render(SkCanvas* canvas) const { |
757 render_bitmap(canvas, fBitmap); | 762 render_bitmap(canvas, fBitmap); |
758 return true; | 763 return true; |
759 } | 764 } |
760 | 765 |
761 SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScal
ar x, SkScalar y, | 766 SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScal
ar x, SkScalar y, |
762 const SkPaint& paint) | 767 const SkPaint& paint) |
763 : INHERITED(DRAW_TEXT) { | 768 : INHERITED(DRAW_TEXT) { |
764 fText = new char[byteLength]; | 769 fText = new char[byteLength]; |
765 memcpy(fText, text, byteLength); | 770 memcpy(fText, text, byteLength); |
766 fByteLength = byteLength; | 771 fByteLength = byteLength; |
767 fX = x; | 772 fX = x; |
768 fY = y; | 773 fY = y; |
769 fPaint = paint; | 774 fPaint = paint; |
770 | 775 |
771 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); | 776 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); |
772 fInfo.push(SkObjectParser::ScalarToString(x, "SkScalar x: ")); | 777 fInfo.push(SkObjectParser::ScalarToString(x, "SkScalar x: ")); |
773 fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: ")); | 778 fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: ")); |
774 fInfo.push(SkObjectParser::PaintToString(paint)); | 779 fInfo.push(SkObjectParser::PaintToString(paint)); |
775 } | 780 } |
776 | 781 |
777 void SkDrawTextCommand::execute(SkCanvas* canvas) const { | 782 void SkDrawTextCommand::execute(SkCanvas* canvas) { |
778 canvas->drawText(fText, fByteLength, fX, fY, fPaint); | 783 canvas->drawText(fText, fByteLength, fX, fY, fPaint); |
779 } | 784 } |
780 | 785 |
781 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLe
ngth, | 786 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLe
ngth, |
782 const SkPath& path, const SkMat
rix* matrix, | 787 const SkPath& path, const SkMat
rix* matrix, |
783 const SkPaint& paint) | 788 const SkPaint& paint) |
784 : INHERITED(DRAW_TEXT_ON_PATH) { | 789 : INHERITED(DRAW_TEXT_ON_PATH) { |
785 fText = new char[byteLength]; | 790 fText = new char[byteLength]; |
786 memcpy(fText, text, byteLength); | 791 memcpy(fText, text, byteLength); |
787 fByteLength = byteLength; | 792 fByteLength = byteLength; |
788 fPath = path; | 793 fPath = path; |
789 if (matrix) { | 794 if (matrix) { |
790 fMatrix = *matrix; | 795 fMatrix = *matrix; |
791 } else { | 796 } else { |
792 fMatrix.setIdentity(); | 797 fMatrix.setIdentity(); |
793 } | 798 } |
794 fPaint = paint; | 799 fPaint = paint; |
795 | 800 |
796 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); | 801 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncod
ing())); |
797 fInfo.push(SkObjectParser::PathToString(path)); | 802 fInfo.push(SkObjectParser::PathToString(path)); |
798 if (matrix) { | 803 if (matrix) { |
799 fInfo.push(SkObjectParser::MatrixToString(*matrix)); | 804 fInfo.push(SkObjectParser::MatrixToString(*matrix)); |
800 } | 805 } |
801 fInfo.push(SkObjectParser::PaintToString(paint)); | 806 fInfo.push(SkObjectParser::PaintToString(paint)); |
802 } | 807 } |
803 | 808 |
804 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) const { | 809 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) { |
805 canvas->drawTextOnPath(fText, fByteLength, fPath, | 810 canvas->drawTextOnPath(fText, fByteLength, fPath, |
806 fMatrix.isIdentity() ? NULL : &fMatrix, | 811 fMatrix.isIdentity() ? NULL : &fMatrix, |
807 fPaint); | 812 fPaint); |
808 } | 813 } |
809 | 814 |
810 SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int ver
texCount, | 815 SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int ver
texCount, |
811 const SkPoint vertices[], const SkP
oint texs[], | 816 const SkPoint vertices[], const SkP
oint texs[], |
812 const SkColor colors[], SkXfermode*
xfermode, | 817 const SkColor colors[], SkXfermode*
xfermode, |
813 const uint16_t indices[], int index
Count, | 818 const uint16_t indices[], int index
Count, |
814 const SkPaint& paint) | 819 const SkPaint& paint) |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
855 } | 860 } |
856 | 861 |
857 SkDrawVerticesCommand::~SkDrawVerticesCommand() { | 862 SkDrawVerticesCommand::~SkDrawVerticesCommand() { |
858 delete [] fVertices; | 863 delete [] fVertices; |
859 delete [] fTexs; | 864 delete [] fTexs; |
860 delete [] fColors; | 865 delete [] fColors; |
861 SkSafeUnref(fXfermode); | 866 SkSafeUnref(fXfermode); |
862 delete [] fIndices; | 867 delete [] fIndices; |
863 } | 868 } |
864 | 869 |
865 void SkDrawVerticesCommand::execute(SkCanvas* canvas) const { | 870 void SkDrawVerticesCommand::execute(SkCanvas* canvas) { |
866 canvas->drawVertices(fVmode, fVertexCount, fVertices, | 871 canvas->drawVertices(fVmode, fVertexCount, fVertices, |
867 fTexs, fColors, fXfermode, fIndices, | 872 fTexs, fColors, fXfermode, fIndices, |
868 fIndexCount, fPaint); | 873 fIndexCount, fPaint); |
869 } | 874 } |
870 | 875 |
871 SkRestoreCommand::SkRestoreCommand() | 876 SkRestoreCommand::SkRestoreCommand() |
872 : INHERITED(RESTORE) { | 877 : INHERITED(RESTORE) { |
873 fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); | 878 fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); |
874 } | 879 } |
875 | 880 |
876 void SkRestoreCommand::execute(SkCanvas* canvas) const { | 881 void SkRestoreCommand::execute(SkCanvas* canvas) { |
877 canvas->restore(); | 882 canvas->restore(); |
878 } | 883 } |
879 | 884 |
880 void SkRestoreCommand::trackSaveState(int* state) { | 885 void SkRestoreCommand::trackSaveState(int* state) { |
881 (*state)--; | 886 (*state)--; |
882 } | 887 } |
883 | 888 |
884 SkRotateCommand::SkRotateCommand(SkScalar degrees) | 889 SkRotateCommand::SkRotateCommand(SkScalar degrees) |
885 : INHERITED(ROTATE) { | 890 : INHERITED(ROTATE) { |
886 fDegrees = degrees; | 891 fDegrees = degrees; |
887 | 892 |
888 fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: ")); | 893 fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: ")); |
889 } | 894 } |
890 | 895 |
891 void SkRotateCommand::execute(SkCanvas* canvas) const { | 896 void SkRotateCommand::execute(SkCanvas* canvas) { |
892 canvas->rotate(fDegrees); | 897 canvas->rotate(fDegrees); |
893 } | 898 } |
894 | 899 |
895 SkSaveCommand::SkSaveCommand() | 900 SkSaveCommand::SkSaveCommand() |
896 : INHERITED(SAVE) { | 901 : INHERITED(SAVE) { |
897 } | 902 } |
898 | 903 |
899 void SkSaveCommand::execute(SkCanvas* canvas) const { | 904 void SkSaveCommand::execute(SkCanvas* canvas) { |
900 canvas->save(); | 905 canvas->save(); |
901 } | 906 } |
902 | 907 |
903 void SkSaveCommand::trackSaveState(int* state) { | 908 void SkSaveCommand::trackSaveState(int* state) { |
904 (*state)++; | 909 (*state)++; |
905 } | 910 } |
906 | 911 |
907 SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* pain
t, | 912 SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* pain
t, |
908 SkCanvas::SaveFlags flags) | 913 SkCanvas::SaveFlags flags) |
909 : INHERITED(SAVE_LAYER) { | 914 : INHERITED(SAVE_LAYER) { |
(...skipping 13 matching lines...) Expand all Loading... |
923 | 928 |
924 if (bounds) { | 929 if (bounds) { |
925 fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: ")); | 930 fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: ")); |
926 } | 931 } |
927 if (paint) { | 932 if (paint) { |
928 fInfo.push(SkObjectParser::PaintToString(*paint)); | 933 fInfo.push(SkObjectParser::PaintToString(*paint)); |
929 } | 934 } |
930 fInfo.push(SkObjectParser::SaveFlagsToString(flags)); | 935 fInfo.push(SkObjectParser::SaveFlagsToString(flags)); |
931 } | 936 } |
932 | 937 |
933 void SkSaveLayerCommand::execute(SkCanvas* canvas) const { | 938 void SkSaveLayerCommand::execute(SkCanvas* canvas) { |
934 canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds, | 939 canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds, |
935 fPaintPtr, | 940 fPaintPtr, |
936 fFlags); | 941 fFlags); |
937 } | 942 } |
938 | 943 |
939 void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) const { | 944 void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) { |
940 canvas->save(); | 945 canvas->save(); |
941 } | 946 } |
942 | 947 |
943 void SkSaveLayerCommand::trackSaveState(int* state) { | 948 void SkSaveLayerCommand::trackSaveState(int* state) { |
944 (*state)++; | 949 (*state)++; |
945 } | 950 } |
946 | 951 |
947 SkScaleCommand::SkScaleCommand(SkScalar sx, SkScalar sy) | 952 SkScaleCommand::SkScaleCommand(SkScalar sx, SkScalar sy) |
948 : INHERITED(SCALE) { | 953 : INHERITED(SCALE) { |
949 fSx = sx; | 954 fSx = sx; |
950 fSy = sy; | 955 fSy = sy; |
951 | 956 |
952 fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); | 957 fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); |
953 fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); | 958 fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); |
954 } | 959 } |
955 | 960 |
956 void SkScaleCommand::execute(SkCanvas* canvas) const { | 961 void SkScaleCommand::execute(SkCanvas* canvas) { |
957 canvas->scale(fSx, fSy); | 962 canvas->scale(fSx, fSy); |
958 } | 963 } |
959 | 964 |
960 SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) | 965 SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) |
961 : INHERITED(SET_MATRIX) { | 966 : INHERITED(SET_MATRIX) { |
962 fUserMatrix.reset(); | 967 fUserMatrix.reset(); |
963 fMatrix = matrix; | 968 fMatrix = matrix; |
964 | 969 |
965 fInfo.push(SkObjectParser::MatrixToString(matrix)); | 970 fInfo.push(SkObjectParser::MatrixToString(matrix)); |
966 } | 971 } |
967 | 972 |
968 void SkSetMatrixCommand::setUserMatrix(const SkMatrix& userMatrix) { | 973 void SkSetMatrixCommand::setUserMatrix(const SkMatrix& userMatrix) { |
969 fUserMatrix = userMatrix; | 974 fUserMatrix = userMatrix; |
970 } | 975 } |
971 | 976 |
972 void SkSetMatrixCommand::execute(SkCanvas* canvas) const { | 977 void SkSetMatrixCommand::execute(SkCanvas* canvas) { |
973 SkMatrix temp = SkMatrix::Concat(fUserMatrix, fMatrix); | 978 SkMatrix temp = SkMatrix::Concat(fUserMatrix, fMatrix); |
974 canvas->setMatrix(temp); | 979 canvas->setMatrix(temp); |
975 } | 980 } |
976 | 981 |
977 SkSkewCommand::SkSkewCommand(SkScalar sx, SkScalar sy) | 982 SkSkewCommand::SkSkewCommand(SkScalar sx, SkScalar sy) |
978 : INHERITED(SKEW) { | 983 : INHERITED(SKEW) { |
979 fSx = sx; | 984 fSx = sx; |
980 fSy = sy; | 985 fSy = sy; |
981 | 986 |
982 fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); | 987 fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); |
983 fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); | 988 fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); |
984 } | 989 } |
985 | 990 |
986 void SkSkewCommand::execute(SkCanvas* canvas) const { | 991 void SkSkewCommand::execute(SkCanvas* canvas) { |
987 canvas->skew(fSx, fSy); | 992 canvas->skew(fSx, fSy); |
988 } | 993 } |
989 | 994 |
990 SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) | 995 SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) |
991 : INHERITED(TRANSLATE) { | 996 : INHERITED(TRANSLATE) { |
992 fDx = dx; | 997 fDx = dx; |
993 fDy = dy; | 998 fDy = dy; |
994 | 999 |
995 fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: ")); | 1000 fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: ")); |
996 fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: ")); | 1001 fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: ")); |
997 } | 1002 } |
998 | 1003 |
999 void SkTranslateCommand::execute(SkCanvas* canvas) const { | 1004 void SkTranslateCommand::execute(SkCanvas* canvas) { |
1000 canvas->translate(fDx, fDy); | 1005 canvas->translate(fDx, fDy); |
1001 } | 1006 } |
1002 | 1007 |
1003 SkPushCullCommand::SkPushCullCommand(const SkRect& cullRect) | 1008 SkPushCullCommand::SkPushCullCommand(const SkRect& cullRect) |
1004 : INHERITED(PUSH_CULL) | 1009 : INHERITED(PUSH_CULL) |
1005 , fCullRect(cullRect) { | 1010 , fCullRect(cullRect) { |
1006 fInfo.push(SkObjectParser::RectToString(cullRect)); | 1011 fInfo.push(SkObjectParser::RectToString(cullRect)); |
1007 } | 1012 } |
1008 | 1013 |
1009 void SkPushCullCommand::execute(SkCanvas* canvas) const { | 1014 void SkPushCullCommand::execute(SkCanvas* canvas) { |
1010 canvas->pushCull(fCullRect); | 1015 canvas->pushCull(fCullRect); |
1011 } | 1016 } |
1012 | 1017 |
1013 void SkPushCullCommand::vizExecute(SkCanvas* canvas) const { | 1018 void SkPushCullCommand::vizExecute(SkCanvas* canvas) { |
1014 canvas->pushCull(fCullRect); | 1019 canvas->pushCull(fCullRect); |
1015 | 1020 |
1016 SkPaint p; | 1021 SkPaint p; |
1017 p.setColor(SK_ColorCYAN); | 1022 p.setColor(SK_ColorCYAN); |
1018 p.setStyle(SkPaint::kStroke_Style); | 1023 p.setStyle(SkPaint::kStroke_Style); |
1019 canvas->drawRect(fCullRect, p); | 1024 canvas->drawRect(fCullRect, p); |
1020 } | 1025 } |
1021 | 1026 |
1022 SkPopCullCommand::SkPopCullCommand() : INHERITED(POP_CULL) { } | 1027 SkPopCullCommand::SkPopCullCommand() : INHERITED(POP_CULL) { } |
1023 | 1028 |
1024 void SkPopCullCommand::execute(SkCanvas* canvas) const { | 1029 void SkPopCullCommand::execute(SkCanvas* canvas) { |
1025 canvas->popCull(); | 1030 canvas->popCull(); |
1026 } | 1031 } |
OLD | NEW |