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