src/third_party/skia/src/utils/debugger/SkDrawCommand.cpp

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