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