1 2/* 3 * Copyright 2012 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10#include "SkDrawCommand.h" 11#include "SkObjectParser.h" 12 13// TODO(chudy): Refactor into non subclass model. 14 15SkDrawCommand::SkDrawCommand(DrawType type) 16 : fDrawType(type) 17 , fVisible(true) { 18} 19 20SkDrawCommand::SkDrawCommand() { 21 fVisible = true; 22} 23 24SkDrawCommand::~SkDrawCommand() { 25 fInfo.deleteAll(); 26} 27 28const char* SkDrawCommand::GetCommandString(DrawType type) { 29 switch (type) { 30 case UNUSED: SkDEBUGFAIL("DrawType UNUSED\n"); break; 31 case DRAW_CLEAR: return "Clear"; 32 case CLIP_PATH: return "Clip Path"; 33 case CLIP_REGION: return "Clip Region"; 34 case CLIP_RECT: return "Clip Rect"; 35 case CLIP_RRECT: return "Clip RRect"; 36 case CONCAT: return "Concat"; 37 case DRAW_BITMAP: return "Draw Bitmap"; 38 case DRAW_BITMAP_MATRIX: return "Draw Bitmap Matrix"; 39 case DRAW_BITMAP_NINE: return "Draw Bitmap Nine"; 40 case DRAW_BITMAP_RECT_TO_RECT: return "Draw Bitmap Rect"; 41 case DRAW_DATA: return "Draw Data"; 42 case DRAW_OVAL: return "Draw Oval"; 43 case DRAW_PAINT: return "Draw Paint"; 44 case DRAW_PATH: return "Draw Path"; 45 case DRAW_PICTURE: return "Draw Picture"; 46 case DRAW_POINTS: return "Draw Points"; 47 case DRAW_POS_TEXT: return "Draw Pos Text"; 48 case DRAW_POS_TEXT_H: return "Draw Pos Text H"; 49 case DRAW_RECT: return "Draw Rect"; 50 case DRAW_RRECT: return "Draw RRect"; 51 case DRAW_SPRITE: return "Draw Sprite"; 52 case DRAW_TEXT: return "Draw Text"; 53 case DRAW_TEXT_ON_PATH: return "Draw Text On Path"; 54 case DRAW_VERTICES: return "Draw Vertices"; 55 case RESTORE: return "Restore"; 56 case ROTATE: return "Rotate"; 57 case SAVE: return "Save"; 58 case SAVE_LAYER: return "Save Layer"; 59 case SCALE: return "Scale"; 60 case SET_MATRIX: return "Set Matrix"; 61 case SKEW: return "Skew"; 62 case TRANSLATE: return "Translate"; 63 case NOOP: return "NoOp"; 64 case BEGIN_COMMENT_GROUP: return "BeginCommentGroup"; 65 case COMMENT: return "Comment"; 66 case END_COMMENT_GROUP: return "EndCommentGroup"; 67 default: 68 SkDebugf("DrawType error 0x%08x\n", type); 69 SkASSERT(0); 70 break; 71 } 72 SkDEBUGFAIL("DrawType UNUSED\n"); 73 return NULL; 74} 75 76SkString SkDrawCommand::toString() { 77 return SkString(GetCommandString(fDrawType)); 78} 79 80SkClearCommand::SkClearCommand(SkColor color) { 81 fColor = color; 82 fDrawType = DRAW_CLEAR; 83 fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); 84} 85 86void SkClearCommand::execute(SkCanvas* canvas) { 87 canvas->clear(fColor); 88} 89 90namespace { 91 92void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) { 93 const SkISize& size = canvas->getDeviceSize(); 94 95 static const SkScalar kInsetFrac = 0.9f; // Leave a border around object 96 97 canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f); 98 if (bounds.width() > bounds.height()) { 99 canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.width()), 100 SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.width())); 101 } else { 102 canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.height()), 103 SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.height())); 104 } 105 canvas->translate(-bounds.centerX(), -bounds.centerY()); 106} 107 108 109void render_path(SkCanvas* canvas, const SkPath& path) { 110 canvas->clear(0xFFFFFFFF); 111 canvas->save(); 112 113 const SkRect& bounds = path.getBounds(); 114 115 xlate_and_scale_to_bounds(canvas, bounds); 116 117 SkPaint p; 118 p.setColor(SK_ColorBLACK); 119 p.setStyle(SkPaint::kStroke_Style); 120 121 canvas->drawPath(path, p); 122 canvas->restore(); 123} 124 125void render_bitmap(SkCanvas* canvas, const SkBitmap& input, const SkRect* srcRect = NULL) { 126 const SkISize& size = canvas->getDeviceSize(); 127 128 SkScalar xScale = SkIntToScalar(size.fWidth-2) / input.width(); 129 SkScalar yScale = SkIntToScalar(size.fHeight-2) / input.height(); 130 131 if (input.width() > input.height()) { 132 yScale *= input.height() / (float) input.width(); 133 } else { 134 xScale *= input.width() / (float) input.height(); 135 } 136 137 SkRect dst = SkRect::MakeXYWH(SK_Scalar1, SK_Scalar1, 138 xScale * input.width(), 139 yScale * input.height()); 140 141 canvas->clear(0xFFFFFFFF); 142 canvas->drawBitmapRect(input, NULL, dst); 143 144 if (NULL != srcRect) { 145 SkRect r = SkRect::MakeLTRB(srcRect->fLeft * xScale + SK_Scalar1, 146 srcRect->fTop * yScale + SK_Scalar1, 147 srcRect->fRight * xScale + SK_Scalar1, 148 srcRect->fBottom * yScale + SK_Scalar1); 149 SkPaint p; 150 p.setColor(SK_ColorRED); 151 p.setStyle(SkPaint::kStroke_Style); 152 153 canvas->drawRect(r, p); 154 } 155} 156 157void render_rrect(SkCanvas* canvas, const SkRRect& rrect) { 158 canvas->clear(0xFFFFFFFF); 159 canvas->save(); 160 161 const SkRect& bounds = rrect.getBounds(); 162 163 xlate_and_scale_to_bounds(canvas, bounds); 164 165 SkPaint p; 166 p.setColor(SK_ColorBLACK); 167 p.setStyle(SkPaint::kStroke_Style); 168 169 canvas->drawRRect(rrect, p); 170 canvas->restore(); 171} 172 173}; 174 175 176SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA) { 177 fPath = path; 178 fOp = op; 179 fDoAA = doAA; 180 fDrawType = CLIP_PATH; 181 182 fInfo.push(SkObjectParser::PathToString(path)); 183 fInfo.push(SkObjectParser::RegionOpToString(op)); 184 fInfo.push(SkObjectParser::BoolToString(doAA)); 185} 186 187void SkClipPathCommand::execute(SkCanvas* canvas) { 188 canvas->clipPath(fPath, fOp, fDoAA); 189} 190 191bool SkClipPathCommand::render(SkCanvas* canvas) const { 192 render_path(canvas, fPath); 193 return true; 194} 195 196SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op) { 197 fRegion = region; 198 fOp = op; 199 fDrawType = CLIP_REGION; 200 201 fInfo.push(SkObjectParser::RegionToString(region)); 202 fInfo.push(SkObjectParser::RegionOpToString(op)); 203} 204 205void SkClipRegionCommand::execute(SkCanvas* canvas) { 206 canvas->clipRegion(fRegion, fOp); 207} 208 209SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA) { 210 fRect = rect; 211 fOp = op; 212 fDoAA = doAA; 213 fDrawType = CLIP_RECT; 214 215 fInfo.push(SkObjectParser::RectToString(rect)); 216 fInfo.push(SkObjectParser::RegionOpToString(op)); 217 fInfo.push(SkObjectParser::BoolToString(doAA)); 218} 219 220void SkClipRectCommand::execute(SkCanvas* canvas) { 221 canvas->clipRect(fRect, fOp, fDoAA); 222} 223 224SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA) { 225 fRRect = rrect; 226 fOp = op; 227 fDoAA = doAA; 228 fDrawType = CLIP_RRECT; 229 230 fInfo.push(SkObjectParser::RRectToString(rrect)); 231 fInfo.push(SkObjectParser::RegionOpToString(op)); 232 fInfo.push(SkObjectParser::BoolToString(doAA)); 233} 234 235void SkClipRRectCommand::execute(SkCanvas* canvas) { 236 canvas->clipRRect(fRRect, fOp, fDoAA); 237} 238 239bool SkClipRRectCommand::render(SkCanvas* canvas) const { 240 render_rrect(canvas, fRRect); 241 return true; 242} 243 244SkConcatCommand::SkConcatCommand(const SkMatrix& matrix) { 245 fMatrix = matrix; 246 fDrawType = CONCAT; 247 248 fInfo.push(SkObjectParser::MatrixToString(matrix)); 249} 250 251void SkConcatCommand::execute(SkCanvas* canvas) { 252 canvas->concat(fMatrix); 253} 254 255SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top, 256 const SkPaint* paint) { 257 fBitmap = bitmap; 258 fLeft = left; 259 fTop = top; 260 if (NULL != paint) { 261 fPaint = *paint; 262 fPaintPtr = &fPaint; 263 } else { 264 fPaintPtr = NULL; 265 } 266 fDrawType = DRAW_BITMAP; 267 268 fInfo.push(SkObjectParser::BitmapToString(bitmap)); 269 fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: ")); 270 fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: ")); 271 if (NULL != paint) { 272 fInfo.push(SkObjectParser::PaintToString(*paint)); 273 } 274} 275 276void SkDrawBitmapCommand::execute(SkCanvas* canvas) { 277 canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr); 278} 279 280bool SkDrawBitmapCommand::render(SkCanvas* canvas) const { 281 render_bitmap(canvas, fBitmap); 282 return true; 283} 284 285SkDrawBitmapMatrixCommand::SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, 286 const SkMatrix& matrix, 287 const SkPaint* paint) { 288 fBitmap = bitmap; 289 fMatrix = matrix; 290 if (NULL != paint) { 291 fPaint = *paint; 292 fPaintPtr = &fPaint; 293 } else { 294 fPaintPtr = NULL; 295 } 296 fDrawType = DRAW_BITMAP_MATRIX; 297 298 fInfo.push(SkObjectParser::BitmapToString(bitmap)); 299 fInfo.push(SkObjectParser::MatrixToString(matrix)); 300 if (NULL != paint) { 301 fInfo.push(SkObjectParser::PaintToString(*paint)); 302 } 303} 304 305void SkDrawBitmapMatrixCommand::execute(SkCanvas* canvas) { 306 canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr); 307} 308 309bool SkDrawBitmapMatrixCommand::render(SkCanvas* canvas) const { 310 render_bitmap(canvas, fBitmap); 311 return true; 312} 313 314SkDrawBitmapNineCommand::SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center, 315 const SkRect& dst, const SkPaint* paint) { 316 fBitmap = bitmap; 317 fCenter = center; 318 fDst = dst; 319 if (NULL != paint) { 320 fPaint = *paint; 321 fPaintPtr = &fPaint; 322 } else { 323 fPaintPtr = NULL; 324 } 325 fDrawType = DRAW_BITMAP_NINE; 326 327 fInfo.push(SkObjectParser::BitmapToString(bitmap)); 328 fInfo.push(SkObjectParser::IRectToString(center)); 329 fInfo.push(SkObjectParser::RectToString(dst, "Dst: ")); 330 if (NULL != paint) { 331 fInfo.push(SkObjectParser::PaintToString(*paint)); 332 } 333} 334 335void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) { 336 canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr); 337} 338 339bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const { 340 render_bitmap(canvas, fBitmap); 341 return true; 342} 343 344SkDrawBitmapRectCommand::SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src, 345 const SkRect& dst, const SkPaint* paint) { 346 fBitmap = bitmap; 347 if (NULL != src) { 348 fSrc = *src; 349 } else { 350 fSrc.setEmpty(); 351 } 352 fDst = dst; 353 354 if (NULL != paint) { 355 fPaint = *paint; 356 fPaintPtr = &fPaint; 357 } else { 358 fPaintPtr = NULL; 359 } 360 fDrawType = DRAW_BITMAP_RECT_TO_RECT; 361 362 fInfo.push(SkObjectParser::BitmapToString(bitmap)); 363 if (NULL != src) { 364 fInfo.push(SkObjectParser::RectToString(*src, "Src: ")); 365 } 366 fInfo.push(SkObjectParser::RectToString(dst, "Dst: ")); 367 if (NULL != paint) { 368 fInfo.push(SkObjectParser::PaintToString(*paint)); 369 } 370} 371 372void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) { 373 canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr); 374} 375 376bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const { 377 render_bitmap(canvas, fBitmap, this->srcRect()); 378 return true; 379} 380 381SkDrawDataCommand::SkDrawDataCommand(const void* data, size_t length) { 382 fData = new char[length]; 383 memcpy(fData, data, length); 384 fLength = length; 385 fDrawType = DRAW_DATA; 386 387 // TODO: add display of actual data? 388 SkString* str = new SkString; 389 str->appendf("length: %d", (int) length); 390 fInfo.push(str); 391} 392 393void SkDrawDataCommand::execute(SkCanvas* canvas) { 394 canvas->drawData(fData, fLength); 395} 396 397SkBeginCommentGroupCommand::SkBeginCommentGroupCommand(const char* description) 398 : INHERITED(BEGIN_COMMENT_GROUP) 399 , fDescription(description) { 400 SkString* temp = new SkString; 401 temp->appendf("Description: %s", description); 402 fInfo.push(temp); 403} 404 405SkCommentCommand::SkCommentCommand(const char* kywd, const char* value) 406 : INHERITED(COMMENT) 407 , fKywd(kywd) 408 , fValue(value) { 409 SkString* temp = new SkString; 410 temp->appendf("%s: %s", kywd, value); 411 fInfo.push(temp); 412} 413 414SkEndCommentGroupCommand::SkEndCommentGroupCommand() : INHERITED(END_COMMENT_GROUP) { 415} 416 417SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint) { 418 fOval = oval; 419 fPaint = paint; 420 fDrawType = DRAW_OVAL; 421 422 fInfo.push(SkObjectParser::RectToString(oval)); 423 fInfo.push(SkObjectParser::PaintToString(paint)); 424} 425 426void SkDrawOvalCommand::execute(SkCanvas* canvas) { 427 canvas->drawOval(fOval, fPaint); 428} 429 430bool SkDrawOvalCommand::render(SkCanvas* canvas) const { 431 canvas->clear(0xFFFFFFFF); 432 canvas->save(); 433 434 xlate_and_scale_to_bounds(canvas, fOval); 435 436 SkPaint p; 437 p.setColor(SK_ColorBLACK); 438 p.setStyle(SkPaint::kStroke_Style); 439 440 canvas->drawOval(fOval, p); 441 canvas->restore(); 442 443 return true; 444} 445 446SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint) { 447 fPaint = paint; 448 fDrawType = DRAW_PAINT; 449 450 fInfo.push(SkObjectParser::PaintToString(paint)); 451} 452 453void SkDrawPaintCommand::execute(SkCanvas* canvas) { 454 canvas->drawPaint(fPaint); 455} 456 457bool SkDrawPaintCommand::render(SkCanvas* canvas) const { 458 canvas->clear(0xFFFFFFFF); 459 canvas->drawPaint(fPaint); 460 return true; 461} 462 463SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint) { 464 fPath = path; 465 fPaint = paint; 466 fDrawType = DRAW_PATH; 467 468 fInfo.push(SkObjectParser::PathToString(path)); 469 fInfo.push(SkObjectParser::PaintToString(paint)); 470} 471 472void SkDrawPathCommand::execute(SkCanvas* canvas) { 473 canvas->drawPath(fPath, fPaint); 474} 475 476bool SkDrawPathCommand::render(SkCanvas* canvas) const { 477 render_path(canvas, fPath); 478 return true; 479} 480 481SkDrawPictureCommand::SkDrawPictureCommand(SkPicture& picture) : 482 fPicture(picture) { 483 fDrawType = DRAW_PICTURE; 484 fInfo.push(SkObjectParser::CustomTextToString("To be implemented.")); 485} 486 487void SkDrawPictureCommand::execute(SkCanvas* canvas) { 488 canvas->drawPicture(fPicture); 489} 490 491SkDrawPointsCommand::SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, 492 const SkPoint pts[], const SkPaint& paint) { 493 fMode = mode; 494 fCount = count; 495 fPts = new SkPoint[count]; 496 memcpy(fPts, pts, count * sizeof(SkPoint)); 497 fPaint = paint; 498 fDrawType = DRAW_POINTS; 499 500 fInfo.push(SkObjectParser::PointsToString(pts, count)); 501 fInfo.push(SkObjectParser::ScalarToString(SkIntToScalar((unsigned int)count), 502 "Points: ")); 503 fInfo.push(SkObjectParser::PointModeToString(mode)); 504 fInfo.push(SkObjectParser::PaintToString(paint)); 505} 506 507void SkDrawPointsCommand::execute(SkCanvas* canvas) { 508 canvas->drawPoints(fMode, fCount, fPts, fPaint); 509} 510 511bool SkDrawPointsCommand::render(SkCanvas* canvas) const { 512 canvas->clear(0xFFFFFFFF); 513 canvas->save(); 514 515 SkRect bounds; 516 517 bounds.setEmpty(); 518 for (unsigned int i = 0; i < fCount; ++i) { 519 bounds.growToInclude(fPts[i].fX, fPts[i].fY); 520 } 521 522 xlate_and_scale_to_bounds(canvas, bounds); 523 524 SkPaint p; 525 p.setColor(SK_ColorBLACK); 526 p.setStyle(SkPaint::kStroke_Style); 527 528 canvas->drawPoints(fMode, fCount, fPts, p); 529 canvas->restore(); 530 531 return true; 532} 533 534SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength, 535 const SkPoint pos[], const SkPaint& paint) { 536 size_t numPts = paint.countText(text, byteLength); 537 538 fText = new char[byteLength]; 539 memcpy(fText, text, byteLength); 540 fByteLength = byteLength; 541 542 fPos = new SkPoint[numPts]; 543 memcpy(fPos, pos, numPts * sizeof(SkPoint)); 544 545 fPaint = paint; 546 fDrawType = DRAW_POS_TEXT; 547 548 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); 549 // TODO(chudy): Test that this works. 550 fInfo.push(SkObjectParser::PointsToString(pos, 1)); 551 fInfo.push(SkObjectParser::PaintToString(paint)); 552} 553 554void SkDrawPosTextCommand::execute(SkCanvas* canvas) { 555 canvas->drawPosText(fText, fByteLength, fPos, fPaint); 556} 557 558 559SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength, 560 const SkScalar xpos[], SkScalar constY, 561 const SkPaint& paint) { 562 size_t numPts = paint.countText(text, byteLength); 563 564 fText = new char[byteLength]; 565 memcpy(fText, text, byteLength); 566 fByteLength = byteLength; 567 568 fXpos = new SkScalar[numPts]; 569 memcpy(fXpos, xpos, numPts * sizeof(SkScalar)); 570 571 fConstY = constY; 572 fPaint = paint; 573 fDrawType = DRAW_POS_TEXT_H; 574 575 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); 576 fInfo.push(SkObjectParser::ScalarToString(xpos[0], "XPOS: ")); 577 fInfo.push(SkObjectParser::ScalarToString(constY, "SkScalar constY: ")); 578 fInfo.push(SkObjectParser::PaintToString(paint)); 579} 580 581void SkDrawPosTextHCommand::execute(SkCanvas* canvas) { 582 canvas->drawPosTextH(fText, fByteLength, fXpos, fConstY, fPaint); 583} 584 585SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint) { 586 fRect = rect; 587 fPaint = paint; 588 fDrawType = DRAW_RECT; 589 590 fInfo.push(SkObjectParser::RectToString(rect)); 591 fInfo.push(SkObjectParser::PaintToString(paint)); 592} 593 594void SkDrawRectCommand::execute(SkCanvas* canvas) { 595 canvas->drawRect(fRect, fPaint); 596} 597 598SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint) { 599 fRRect = rrect; 600 fPaint = paint; 601 fDrawType = DRAW_RRECT; 602 603 fInfo.push(SkObjectParser::RRectToString(rrect)); 604 fInfo.push(SkObjectParser::PaintToString(paint)); 605} 606 607void SkDrawRRectCommand::execute(SkCanvas* canvas) { 608 canvas->drawRRect(fRRect, fPaint); 609} 610 611bool SkDrawRRectCommand::render(SkCanvas* canvas) const { 612 render_rrect(canvas, fRRect); 613 return true; 614} 615 616SkDrawSpriteCommand::SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, 617 const SkPaint* paint) { 618 fBitmap = bitmap; 619 fLeft = left; 620 fTop = top; 621 if (NULL != paint) { 622 fPaint = *paint; 623 fPaintPtr = &fPaint; 624 } else { 625 fPaintPtr = NULL; 626 } 627 fDrawType = DRAW_SPRITE; 628 629 fInfo.push(SkObjectParser::BitmapToString(bitmap)); 630 fInfo.push(SkObjectParser::IntToString(left, "Left: ")); 631 fInfo.push(SkObjectParser::IntToString(top, "Top: ")); 632 if (NULL != paint) { 633 fInfo.push(SkObjectParser::PaintToString(*paint)); 634 } 635} 636 637void SkDrawSpriteCommand::execute(SkCanvas* canvas) { 638 canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr); 639} 640 641bool SkDrawSpriteCommand::render(SkCanvas* canvas) const { 642 render_bitmap(canvas, fBitmap); 643 return true; 644} 645 646SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y, 647 const SkPaint& paint) { 648 fText = new char[byteLength]; 649 memcpy(fText, text, byteLength); 650 fByteLength = byteLength; 651 fX = x; 652 fY = y; 653 fPaint = paint; 654 fDrawType = DRAW_TEXT; 655 656 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); 657 fInfo.push(SkObjectParser::ScalarToString(x, "SkScalar x: ")); 658 fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: ")); 659 fInfo.push(SkObjectParser::PaintToString(paint)); 660} 661 662void SkDrawTextCommand::execute(SkCanvas* canvas) { 663 canvas->drawText(fText, fByteLength, fX, fY, fPaint); 664} 665 666SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength, 667 const SkPath& path, const SkMatrix* matrix, 668 const SkPaint& paint) { 669 fText = new char[byteLength]; 670 memcpy(fText, text, byteLength); 671 fByteLength = byteLength; 672 fPath = path; 673 if (NULL != matrix) { 674 fMatrix = *matrix; 675 } else { 676 fMatrix.setIdentity(); 677 } 678 fPaint = paint; 679 fDrawType = DRAW_TEXT_ON_PATH; 680 681 fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding())); 682 fInfo.push(SkObjectParser::PathToString(path)); 683 if (NULL != matrix) { 684 fInfo.push(SkObjectParser::MatrixToString(*matrix)); 685 } 686 fInfo.push(SkObjectParser::PaintToString(paint)); 687} 688 689void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) { 690 canvas->drawTextOnPath(fText, fByteLength, fPath, 691 fMatrix.isIdentity() ? NULL : &fMatrix, 692 fPaint); 693} 694 695SkDrawVerticesCommand::SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount, 696 const SkPoint vertices[], const SkPoint texs[], 697 const SkColor colors[], SkXfermode* xfermode, 698 const uint16_t indices[], int indexCount, 699 const SkPaint& paint) { 700 fVmode = vmode; 701 702 fVertexCount = vertexCount; 703 704 fVertices = new SkPoint[vertexCount]; 705 memcpy(fVertices, vertices, vertexCount * sizeof(SkPoint)); 706 707 if (NULL != texs) { 708 fTexs = new SkPoint[vertexCount]; 709 memcpy(fTexs, texs, vertexCount * sizeof(SkPoint)); 710 } else { 711 fTexs = NULL; 712 } 713 714 if (NULL != colors) { 715 fColors = new SkColor[vertexCount]; 716 memcpy(fColors, colors, vertexCount * sizeof(SkColor)); 717 } else { 718 fColors = NULL; 719 } 720 721 fXfermode = xfermode; 722 if (NULL != fXfermode) { 723 fXfermode->ref(); 724 } 725 726 if (indexCount > 0) { 727 fIndices = new uint16_t[indexCount]; 728 memcpy(fIndices, indices, indexCount * sizeof(uint16_t)); 729 } else { 730 fIndices = NULL; 731 } 732 733 fIndexCount = indexCount; 734 fPaint = paint; 735 fDrawType = DRAW_VERTICES; 736 737 // TODO(chudy) 738 fInfo.push(SkObjectParser::CustomTextToString("To be implemented.")); 739 fInfo.push(SkObjectParser::PaintToString(paint)); 740} 741 742SkDrawVerticesCommand::~SkDrawVerticesCommand() { 743 delete [] fVertices; 744 delete [] fTexs; 745 delete [] fColors; 746 SkSafeUnref(fXfermode); 747 delete [] fIndices; 748} 749 750void SkDrawVerticesCommand::execute(SkCanvas* canvas) { 751 canvas->drawVertices(fVmode, fVertexCount, fVertices, 752 fTexs, fColors, fXfermode, fIndices, 753 fIndexCount, fPaint); 754} 755 756SkRestoreCommand::SkRestoreCommand() { 757 fDrawType = RESTORE; 758 fInfo.push(SkObjectParser::CustomTextToString("No Parameters")); 759} 760 761void SkRestoreCommand::execute(SkCanvas* canvas) { 762 canvas->restore(); 763} 764 765void SkRestoreCommand::trackSaveState(int* state) { 766 (*state)--; 767} 768 769SkRotateCommand::SkRotateCommand(SkScalar degrees) { 770 fDegrees = degrees; 771 fDrawType = ROTATE; 772 773 fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: ")); 774} 775 776void SkRotateCommand::execute(SkCanvas* canvas) { 777 canvas->rotate(fDegrees); 778} 779 780SkSaveCommand::SkSaveCommand(SkCanvas::SaveFlags flags) { 781 fFlags = flags; 782 fDrawType = SAVE; 783 fInfo.push(SkObjectParser::SaveFlagsToString(flags)); 784} 785 786void SkSaveCommand::execute(SkCanvas* canvas) { 787 canvas->save(fFlags); 788} 789 790void SkSaveCommand::trackSaveState(int* state) { 791 (*state)++; 792} 793 794SkSaveLayerCommand::SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint, 795 SkCanvas::SaveFlags flags) { 796 if (NULL != bounds) { 797 fBounds = *bounds; 798 } else { 799 fBounds.setEmpty(); 800 } 801 802 if (NULL != paint) { 803 fPaint = *paint; 804 fPaintPtr = &fPaint; 805 } else { 806 fPaintPtr = NULL; 807 } 808 fFlags = flags; 809 fDrawType = SAVE_LAYER; 810 811 if (NULL != bounds) { 812 fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: ")); 813 } 814 if (NULL != paint) { 815 fInfo.push(SkObjectParser::PaintToString(*paint)); 816 } 817 fInfo.push(SkObjectParser::SaveFlagsToString(flags)); 818} 819 820void SkSaveLayerCommand::execute(SkCanvas* canvas) { 821 canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds, 822 fPaintPtr, 823 fFlags); 824} 825 826void SkSaveLayerCommand::trackSaveState(int* state) { 827 (*state)++; 828} 829 830SkScaleCommand::SkScaleCommand(SkScalar sx, SkScalar sy) { 831 fSx = sx; 832 fSy = sy; 833 fDrawType = SCALE; 834 835 fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); 836 fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); 837} 838 839void SkScaleCommand::execute(SkCanvas* canvas) { 840 canvas->scale(fSx, fSy); 841} 842 843SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix) { 844 fMatrix = matrix; 845 fDrawType = SET_MATRIX; 846 847 fInfo.push(SkObjectParser::MatrixToString(matrix)); 848} 849 850void SkSetMatrixCommand::execute(SkCanvas* canvas) { 851 canvas->setMatrix(fMatrix); 852} 853 854SkSkewCommand::SkSkewCommand(SkScalar sx, SkScalar sy) { 855 fSx = sx; 856 fSy = sy; 857 fDrawType = SKEW; 858 859 fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: ")); 860 fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: ")); 861} 862 863void SkSkewCommand::execute(SkCanvas* canvas) { 864 canvas->skew(fSx, fSy); 865} 866 867SkTranslateCommand::SkTranslateCommand(SkScalar dx, SkScalar dy) { 868 fDx = dx; 869 fDy = dy; 870 fDrawType = TRANSLATE; 871 872 fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: ")); 873 fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: ")); 874} 875 876void SkTranslateCommand::execute(SkCanvas* canvas) { 877 canvas->translate(fDx, fDy); 878} 879