src/utils/debugger/SkDrawCommand.h

   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 #ifndef SKDRAWCOMMAND_H_
  10 #define SKDRAWCOMMAND_H_
  11
  12 #include "SkCanvas.h"
  13 #include "SkString.h"
  14
  15 class SK_API SkDrawCommand {
  16 public:
  17     enum OpType {
  18         kBeginCommentGroup_OpType,
  19         kClipPath_OpType,
  20         kClipRegion_OpType,
  21         kClipRect_OpType,
  22         kClipRRect_OpType,
  23         kComment_OpType,
  24         kConcat_OpType,
  25         kDrawBitmap_OpType,
  26         kDrawBitmapNine_OpType,
  27         kDrawBitmapRect_OpType,
  28         kDrawClear_OpType,
  29         kDrawDRRect_OpType,
  30         kDrawOval_OpType,
  31         kDrawPaint_OpType,
  32         kDrawPatch_OpType,
  33         kDrawPath_OpType,
  34         kDrawPicture_OpType,
  35         kDrawPoints_OpType,
  36         kDrawPosText_OpType,
  37         kDrawPosTextH_OpType,
  38         kDrawRect_OpType,
  39         kDrawRRect_OpType,
  40         kDrawSprite_OpType,
  41         kDrawText_OpType,
  42         kDrawTextBlob_OpType,
  43         kDrawTextOnPath_OpType,
  44         kDrawVertices_OpType,
  45         kEndCommentGroup_OpType,
  46         kRestore_OpType,
  47         kSave_OpType,
  48         kSaveLayer_OpType,
  49         kSetMatrix_OpType,
  50
  51         kLast_OpType = kSetMatrix_OpType
  52     };
  53
  54     static const int kOpTypeCount = kLast_OpType + 1;
  55
  56     SkDrawCommand(OpType opType);
  57
  58     virtual ~SkDrawCommand();
  59
  60     virtual SkString toString() const;
  61
  62     void setOffset(size_t offset) { fOffset = offset; }
  63     size_t offset() const { return fOffset; }
  64
  65     virtual const char* toCString() const {
  66         return GetCommandString(fOpType);
  67     }
  68
  69     bool isVisible() const {
  70         return fVisible;
  71     }
  72
  73     void setVisible(bool toggle) {
  74         fVisible = toggle;
  75     }
  76
  77     const SkTDArray<SkString*>* Info() const { return &fInfo; }
  78     virtual void execute(SkCanvas*) const = 0;
  79     virtual void vizExecute(SkCanvas*) const {}
  80
  81     virtual void setUserMatrix(const SkMatrix&) {}
  82
  83     // The next "active" system is only used by save, saveLayer, and restore.
  84     // It is used to determine which saveLayers are currently active (at a
  85     // given point in the rendering).
  86     //      saves just return a kPushLayer action but don't track active state
  87     //      restores just return a kPopLayer action
  88     //      saveLayers return kPushLayer but also track the active state
  89     enum Action {
  90         kNone_Action,
  91         kPopLayer_Action,
  92         kPushLayer_Action,
  93     };
  94     virtual Action action() const { return kNone_Action; }
  95     virtual void setActive(bool active) {}
  96     virtual bool active() const { return false; }
  97
  98     OpType getType() const { return fOpType; }
  99
 100     virtual bool render(SkCanvas* canvas) const { return false; }
 101
 102     static const char* GetCommandString(OpType type);
 103
 104 protected:
 105     SkTDArray<SkString*> fInfo;
 106
 107 private:
 108     OpType fOpType;
 109     size_t fOffset;
 110     bool   fVisible;
 111 };
 112
 113 class SkRestoreCommand : public SkDrawCommand {
 114 public:
 115     SkRestoreCommand();
 116     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 117     Action action() const SK_OVERRIDE { return kPopLayer_Action; }
 118
 119 private:
 120     typedef SkDrawCommand INHERITED;
 121 };
 122
 123 class SkClearCommand : public SkDrawCommand {
 124 public:
 125     SkClearCommand(SkColor color);
 126     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 127 private:
 128     SkColor fColor;
 129
 130     typedef SkDrawCommand INHERITED;
 131 };
 132
 133 class SkClipPathCommand : public SkDrawCommand {
 134 public:
 135     SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA);
 136     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 137     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 138 private:
 139     SkPath       fPath;
 140     SkRegion::Op fOp;
 141     bool         fDoAA;
 142
 143     typedef SkDrawCommand INHERITED;
 144 };
 145
 146 class SkClipRegionCommand : public SkDrawCommand {
 147 public:
 148     SkClipRegionCommand(const SkRegion& region, SkRegion::Op op);
 149     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 150 private:
 151     SkRegion     fRegion;
 152     SkRegion::Op fOp;
 153
 154     typedef SkDrawCommand INHERITED;
 155 };
 156
 157 class SkClipRectCommand : public SkDrawCommand {
 158 public:
 159     SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA);
 160     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 161
 162     const SkRect& rect() const { return fRect; }
 163     SkRegion::Op op() const { return fOp; }
 164     bool doAA() const { return fDoAA; }
 165
 166 private:
 167     SkRect       fRect;
 168     SkRegion::Op fOp;
 169     bool         fDoAA;
 170
 171     typedef SkDrawCommand INHERITED;
 172 };
 173
 174 class SkClipRRectCommand : public SkDrawCommand {
 175 public:
 176     SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA);
 177     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 178     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 179
 180     const SkRRect& rrect() const { return fRRect; }
 181     SkRegion::Op op() const { return fOp; }
 182     bool doAA() const { return fDoAA; }
 183
 184 private:
 185     SkRRect      fRRect;
 186     SkRegion::Op fOp;
 187     bool         fDoAA;
 188
 189     typedef SkDrawCommand INHERITED;
 190 };
 191
 192 class SkConcatCommand : public SkDrawCommand {
 193 public:
 194     SkConcatCommand(const SkMatrix& matrix);
 195     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 196 private:
 197     SkMatrix fMatrix;
 198
 199     typedef SkDrawCommand INHERITED;
 200 };
 201
 202 class SkDrawBitmapCommand : public SkDrawCommand {
 203 public:
 204     SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
 205                         const SkPaint* paint);
 206     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 207     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 208 private:
 209     SkBitmap fBitmap;
 210     SkScalar fLeft;
 211     SkScalar fTop;
 212     SkPaint  fPaint;
 213     SkPaint* fPaintPtr;
 214
 215     typedef SkDrawCommand INHERITED;
 216 };
 217
 218 class SkDrawBitmapNineCommand : public SkDrawCommand {
 219 public:
 220     SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
 221                             const SkRect& dst, const SkPaint* paint);
 222     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 223     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 224 private:
 225     SkBitmap fBitmap;
 226     SkIRect  fCenter;
 227     SkRect   fDst;
 228     SkPaint  fPaint;
 229     SkPaint* fPaintPtr;
 230
 231     typedef SkDrawCommand INHERITED;
 232 };
 233
 234 class SkDrawBitmapRectCommand : public SkDrawCommand {
 235 public:
 236     SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
 237                             const SkRect& dst, const SkPaint* paint,
 238                             SkCanvas::DrawBitmapRectFlags flags);
 239     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 240     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 241
 242     const SkBitmap& bitmap() const { return fBitmap; }
 243
 244     // The non-const 'paint' method allows modification of this object's
 245     // SkPaint. For this reason the ctor and setPaint method make a local copy.
 246     // The 'fPaintPtr' member acts a signal that the local SkPaint is valid
 247     // (since only an SkPaint* is passed into the ctor).
 248     const SkPaint* paint() const { return fPaintPtr; }
 249     SkPaint* paint() { return fPaintPtr; }
 250
 251     void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; }
 252
 253     const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; }
 254     void setSrcRect(const SkRect& src) { fSrc = src; }
 255
 256     const SkRect& dstRect() const { return fDst; }
 257     void setDstRect(const SkRect& dst) { fDst = dst; }
 258
 259     SkCanvas::DrawBitmapRectFlags flags() const { return fFlags; }
 260     void setFlags(SkCanvas::DrawBitmapRectFlags flags) { fFlags = flags; }
 261
 262 private:
 263     SkBitmap                      fBitmap;
 264     SkRect                        fSrc;
 265     SkRect                        fDst;
 266     SkPaint                       fPaint;
 267     SkPaint*                      fPaintPtr;
 268     SkCanvas::DrawBitmapRectFlags fFlags;
 269
 270     typedef SkDrawCommand INHERITED;
 271 };
 272
 273 class SkBeginCommentGroupCommand : public SkDrawCommand {
 274 public:
 275     SkBeginCommentGroupCommand(const char* description);
 276     void execute(SkCanvas* canvas) const SK_OVERRIDE {
 277         canvas->beginCommentGroup(fDescription.c_str());
 278     };
 279 private:
 280     SkString fDescription;
 281
 282     typedef SkDrawCommand INHERITED;
 283 };
 284
 285 class SkCommentCommand : public SkDrawCommand {
 286 public:
 287     SkCommentCommand(const char* kywd, const char* value);
 288     void execute(SkCanvas* canvas) const SK_OVERRIDE {
 289         canvas->addComment(fKywd.c_str(), fValue.c_str());
 290     };
 291 private:
 292     SkString fKywd;
 293     SkString fValue;
 294
 295     typedef SkDrawCommand INHERITED;
 296 };
 297
 298 class SkEndCommentGroupCommand : public SkDrawCommand {
 299 public:
 300     SkEndCommentGroupCommand();
 301     void execute(SkCanvas* canvas) const SK_OVERRIDE {
 302         canvas->endCommentGroup();
 303     };
 304 private:
 305     typedef SkDrawCommand INHERITED;
 306 };
 307
 308 class SkDrawOvalCommand : public SkDrawCommand {
 309 public:
 310     SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint);
 311     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 312     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 313 private:
 314     SkRect  fOval;
 315     SkPaint fPaint;
 316
 317     typedef SkDrawCommand INHERITED;
 318 };
 319
 320 class SkDrawPaintCommand : public SkDrawCommand {
 321 public:
 322     SkDrawPaintCommand(const SkPaint& paint);
 323     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 324     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 325 private:
 326     SkPaint fPaint;
 327
 328     typedef SkDrawCommand INHERITED;
 329 };
 330
 331 class SkDrawPathCommand : public SkDrawCommand {
 332 public:
 333     SkDrawPathCommand(const SkPath& path, const SkPaint& paint);
 334     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 335     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 336
 337 private:
 338     SkPath   fPath;
 339     SkPaint  fPaint;
 340
 341     typedef SkDrawCommand INHERITED;
 342 };
 343
 344 class SkDrawPictureCommand : public SkDrawCommand {
 345 public:
 346     SkDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint);
 347     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 348     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 349
 350 private:
 351     SkAutoTUnref<const SkPicture> fPicture;
 352     SkMatrix                      fMatrix;
 353     SkMatrix*                     fMatrixPtr;
 354     SkPaint                       fPaint;
 355     SkPaint*                      fPaintPtr;
 356
 357     typedef SkDrawCommand INHERITED;
 358 };
 359
 360 class SkDrawPointsCommand : public SkDrawCommand {
 361 public:
 362     SkDrawPointsCommand(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],
 363                         const SkPaint& paint);
 364     virtual ~SkDrawPointsCommand() { delete [] fPts; }
 365     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 366     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 367 private:
 368     SkCanvas::PointMode fMode;
 369     size_t              fCount;
 370     SkPoint*            fPts;
 371     SkPaint             fPaint;
 372
 373     typedef SkDrawCommand INHERITED;
 374 };
 375
 376 class SkDrawTextCommand : public SkDrawCommand {
 377 public:
 378     SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,
 379                       const SkPaint& paint);
 380     virtual ~SkDrawTextCommand() { delete [] fText; }
 381     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 382 private:
 383     char*    fText;
 384     size_t   fByteLength;
 385     SkScalar fX;
 386     SkScalar fY;
 387     SkPaint  fPaint;
 388
 389     typedef SkDrawCommand INHERITED;
 390 };
 391
 392 class SkDrawPosTextCommand : public SkDrawCommand {
 393 public:
 394     SkDrawPosTextCommand(const void* text, size_t byteLength, const SkPoint pos[],
 395                          const SkPaint& paint);
 396     virtual ~SkDrawPosTextCommand() { delete [] fPos; delete [] fText; }
 397     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 398 private:
 399     char*    fText;
 400     size_t   fByteLength;
 401     SkPoint* fPos;
 402     SkPaint  fPaint;
 403
 404     typedef SkDrawCommand INHERITED;
 405 };
 406
 407 class SkDrawTextOnPathCommand : public SkDrawCommand {
 408 public:
 409     SkDrawTextOnPathCommand(const void* text, size_t byteLength, const SkPath& path,
 410                             const SkMatrix* matrix, const SkPaint& paint);
 411     virtual ~SkDrawTextOnPathCommand() { delete [] fText; }
 412     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 413 private:
 414     char*    fText;
 415     size_t   fByteLength;
 416     SkPath   fPath;
 417     SkMatrix fMatrix;
 418     SkPaint  fPaint;
 419
 420     typedef SkDrawCommand INHERITED;
 421 };
 422
 423 class SkDrawPosTextHCommand : public SkDrawCommand {
 424 public:
 425     SkDrawPosTextHCommand(const void* text, size_t byteLength, const SkScalar xpos[],
 426                           SkScalar constY, const SkPaint& paint);
 427     virtual ~SkDrawPosTextHCommand() { delete [] fXpos; delete [] fText; }
 428     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 429 private:
 430     SkScalar* fXpos;
 431     char*     fText;
 432     size_t    fByteLength;
 433     SkScalar  fConstY;
 434     SkPaint   fPaint;
 435
 436     typedef SkDrawCommand INHERITED;
 437 };
 438
 439 class SkDrawTextBlobCommand : public SkDrawCommand {
 440 public:
 441     SkDrawTextBlobCommand(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint);
 442
 443     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 444     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 445
 446 private:
 447     SkAutoTUnref<const SkTextBlob> fBlob;
 448     SkScalar                       fXPos;
 449     SkScalar                       fYPos;
 450     SkPaint                        fPaint;
 451
 452     typedef SkDrawCommand INHERITED;
 453 };
 454
 455 class SkDrawPatchCommand : public SkDrawCommand {
 456 public:
 457     SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
 458                        const SkPoint texCoords[4], SkXfermode* xmode,
 459                        const SkPaint& paint);
 460     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 461
 462 private:
 463     SkPoint fCubics[12];
 464     SkColor fColors[4];
 465     SkPoint fTexCoords[4];
 466     SkAutoTUnref<SkXfermode> fXfermode;
 467     SkPaint fPaint;
 468
 469     typedef SkDrawCommand INHERITED;
 470 };
 471
 472
 473 class SkDrawRectCommand : public SkDrawCommand {
 474 public:
 475     SkDrawRectCommand(const SkRect& rect, const SkPaint& paint);
 476     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 477
 478     const SkRect& rect() const   { return fRect; }
 479     const SkPaint& paint() const { return fPaint; }
 480 private:
 481     SkRect  fRect;
 482     SkPaint fPaint;
 483
 484     typedef SkDrawCommand INHERITED;
 485 };
 486
 487 class SkDrawRRectCommand : public SkDrawCommand {
 488 public:
 489     SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint);
 490     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 491     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 492 private:
 493     SkRRect fRRect;
 494     SkPaint fPaint;
 495
 496     typedef SkDrawCommand INHERITED;
 497 };
 498
 499 class SkDrawDRRectCommand : public SkDrawCommand {
 500 public:
 501     SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner,
 502                         const SkPaint& paint);
 503     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 504     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 505 private:
 506     SkRRect fOuter;
 507     SkRRect fInner;
 508     SkPaint fPaint;
 509
 510     typedef SkDrawCommand INHERITED;
 511 };
 512
 513 class SkDrawSpriteCommand : public SkDrawCommand {
 514 public:
 515     SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);
 516     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 517     bool render(SkCanvas* canvas) const SK_OVERRIDE;
 518 private:
 519     SkBitmap fBitmap;
 520     int      fLeft;
 521     int      fTop;
 522     SkPaint  fPaint;
 523     SkPaint* fPaintPtr;
 524
 525     typedef SkDrawCommand INHERITED;
 526 };
 527
 528 class SkDrawVerticesCommand : public SkDrawCommand {
 529 public:
 530     SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
 531                           const SkPoint vertices[], const SkPoint texs[],
 532                           const SkColor colors[], SkXfermode* xfermode,
 533                           const uint16_t indices[], int indexCount,
 534                           const SkPaint& paint);
 535     virtual ~SkDrawVerticesCommand();
 536     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 537 private:
 538     SkCanvas::VertexMode fVmode;
 539     int         fVertexCount;
 540     SkPoint*    fVertices;
 541     SkPoint*    fTexs;
 542     SkColor*    fColors;
 543     SkXfermode* fXfermode;
 544     uint16_t*   fIndices;
 545     int         fIndexCount;
 546     SkPaint     fPaint;
 547
 548     typedef SkDrawCommand INHERITED;
 549 };
 550
 551 class SkSaveCommand : public SkDrawCommand {
 552 public:
 553     SkSaveCommand();
 554     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 555     Action action() const SK_OVERRIDE { return kPushLayer_Action; }
 556 private:
 557     typedef SkDrawCommand INHERITED;
 558 };
 559
 560 class SkSaveLayerCommand : public SkDrawCommand {
 561 public:
 562     SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
 563                        SkCanvas::SaveFlags flags);
 564     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 565     void vizExecute(SkCanvas* canvas) const SK_OVERRIDE;
 566     Action action() const SK_OVERRIDE{ return kPushLayer_Action; }
 567     void setActive(bool active) SK_OVERRIDE { fActive = active; }
 568     bool active() const SK_OVERRIDE { return fActive; }
 569
 570     const SkPaint* paint() const { return fPaintPtr; }
 571
 572 private:
 573     SkRect              fBounds;
 574     SkPaint             fPaint;
 575     SkPaint*            fPaintPtr;
 576     SkCanvas::SaveFlags fFlags;
 577
 578     bool                fActive;
 579
 580     typedef SkDrawCommand INHERITED;
 581 };
 582
 583 class SkSetMatrixCommand : public SkDrawCommand {
 584 public:
 585     SkSetMatrixCommand(const SkMatrix& matrix);
 586     void setUserMatrix(const SkMatrix&) SK_OVERRIDE;
 587     void execute(SkCanvas* canvas) const SK_OVERRIDE;
 588 private:
 589     SkMatrix fUserMatrix;
 590     SkMatrix fMatrix;
 591
 592     typedef SkDrawCommand INHERITED;
 593 };
 594
 595 #endif