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     /** Does nothing by default, but used by save() and restore()-type
  45         subclasses to track unresolved save() calls. */
  46     virtual void trackSaveState(int* state) { };
  47
  48     // The next "active" system is only used by save, saveLayer, restore,
  49     // pushCull and popCull. It is used in two ways:
  50     // To determine which saveLayers are currently active (at a
  51     // given point in the rendering).
  52     //      saves just return a kPushLayer action but don't track active state
  53     //      restores just return a kPopLayer action
  54     //      saveLayers return kPushLayer but also track the active state
  55     // To determine which culls are currently active (at a given point)
  56     // in the rendering).
  57     //      pushCulls return a kPushCull action
  58     //      popCulls  return a kPopCull action
  59     enum Action {
  60         kNone_Action,
  61         kPopLayer_Action,
  62         kPushLayer_Action,
  63         kPopCull_Action,
  64         kPushCull_Action
  65     };
  66     virtual Action action() const { return kNone_Action; }
  67     virtual void setActive(bool active) {}
  68     virtual bool active() const { return false; }
  69
  70     DrawType getType() { return fDrawType; };
  71
  72     virtual bool render(SkCanvas* canvas) const { return false; }
  73
  74     static const char* GetCommandString(DrawType type);
  75
  76 protected:
  77     SkTDArray<SkString*> fInfo;
  78
  79 private:
  80     DrawType fDrawType;
  81     size_t fOffset;
  82     bool   fVisible;
  83 };
  84
  85 class SkRestoreCommand : public SkDrawCommand {
  86 public:
  87     SkRestoreCommand();
  88     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
  89     virtual void trackSaveState(int* state) SK_OVERRIDE;
  90     virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; }
  91
  92 private:
  93     typedef SkDrawCommand INHERITED;
  94 };
  95
  96 class SkClearCommand : public SkDrawCommand {
  97 public:
  98     SkClearCommand(SkColor color);
  99     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 100 private:
 101     SkColor fColor;
 102
 103     typedef SkDrawCommand INHERITED;
 104 };
 105
 106 class SkClipPathCommand : public SkDrawCommand {
 107 public:
 108     SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA);
 109     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 110     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 111 private:
 112     SkPath       fPath;
 113     SkRegion::Op fOp;
 114     bool         fDoAA;
 115
 116     typedef SkDrawCommand INHERITED;
 117 };
 118
 119 class SkClipRegionCommand : public SkDrawCommand {
 120 public:
 121     SkClipRegionCommand(const SkRegion& region, SkRegion::Op op);
 122     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 123 private:
 124     SkRegion     fRegion;
 125     SkRegion::Op fOp;
 126
 127     typedef SkDrawCommand INHERITED;
 128 };
 129
 130 class SkClipRectCommand : public SkDrawCommand {
 131 public:
 132     SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA);
 133     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 134
 135     const SkRect& rect() const { return fRect; }
 136     SkRegion::Op op() const { return fOp; }
 137     bool doAA() const { return fDoAA; }
 138
 139 private:
 140     SkRect       fRect;
 141     SkRegion::Op fOp;
 142     bool         fDoAA;
 143
 144     typedef SkDrawCommand INHERITED;
 145 };
 146
 147 class SkClipRRectCommand : public SkDrawCommand {
 148 public:
 149     SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA);
 150     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 151     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 152
 153     const SkRRect& rrect() const { return fRRect; }
 154     SkRegion::Op op() const { return fOp; }
 155     bool doAA() const { return fDoAA; }
 156
 157 private:
 158     SkRRect      fRRect;
 159     SkRegion::Op fOp;
 160     bool         fDoAA;
 161
 162     typedef SkDrawCommand INHERITED;
 163 };
 164
 165 class SkConcatCommand : public SkDrawCommand {
 166 public:
 167     SkConcatCommand(const SkMatrix& matrix);
 168     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 169 private:
 170     SkMatrix fMatrix;
 171
 172     typedef SkDrawCommand INHERITED;
 173 };
 174
 175 class SkDrawBitmapCommand : public SkDrawCommand {
 176 public:
 177     SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
 178                         const SkPaint* paint);
 179     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 180     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 181 private:
 182     SkBitmap fBitmap;
 183     SkScalar fLeft;
 184     SkScalar fTop;
 185     SkPaint  fPaint;
 186     SkPaint* fPaintPtr;
 187
 188     typedef SkDrawCommand INHERITED;
 189 };
 190
 191 class SkDrawBitmapMatrixCommand : public SkDrawCommand {
 192 public:
 193     SkDrawBitmapMatrixCommand(const SkBitmap& bitmap, const SkMatrix& matrix,
 194                               const SkPaint* paint);
 195     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 196     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 197 private:
 198     SkBitmap fBitmap;
 199     SkMatrix fMatrix;
 200     SkPaint  fPaint;
 201     SkPaint* fPaintPtr;
 202
 203     typedef SkDrawCommand INHERITED;
 204 };
 205
 206 class SkDrawBitmapNineCommand : public SkDrawCommand {
 207 public:
 208     SkDrawBitmapNineCommand(const SkBitmap& bitmap, const SkIRect& center,
 209                             const SkRect& dst, const SkPaint* paint);
 210     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 211     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 212 private:
 213     SkBitmap fBitmap;
 214     SkIRect  fCenter;
 215     SkRect   fDst;
 216     SkPaint  fPaint;
 217     SkPaint* fPaintPtr;
 218
 219     typedef SkDrawCommand INHERITED;
 220 };
 221
 222 class SkDrawBitmapRectCommand : public SkDrawCommand {
 223 public:
 224     SkDrawBitmapRectCommand(const SkBitmap& bitmap, const SkRect* src,
 225                             const SkRect& dst, const SkPaint* paint,
 226                             SkCanvas::DrawBitmapRectFlags flags);
 227     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 228     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 229
 230     const SkBitmap& bitmap() const { return fBitmap; }
 231
 232     // The non-const 'paint' method allows modification of this object's
 233     // SkPaint. For this reason the ctor and setPaint method make a local copy.
 234     // The 'fPaintPtr' member acts a signal that the local SkPaint is valid
 235     // (since only an SkPaint* is passed into the ctor).
 236     const SkPaint* paint() const { return fPaintPtr; }
 237     SkPaint* paint() { return fPaintPtr; }
 238
 239     void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; }
 240
 241     const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; }
 242     void setSrcRect(const SkRect& src) { fSrc = src; }
 243
 244     const SkRect& dstRect() const { return fDst; }
 245     void setDstRect(const SkRect& dst) { fDst = dst; }
 246
 247     SkCanvas::DrawBitmapRectFlags flags() const { return fFlags; }
 248     void setFlags(SkCanvas::DrawBitmapRectFlags flags) { fFlags = flags; }
 249
 250 private:
 251     SkBitmap                      fBitmap;
 252     SkRect                        fSrc;
 253     SkRect                        fDst;
 254     SkPaint                       fPaint;
 255     SkPaint*                      fPaintPtr;
 256     SkCanvas::DrawBitmapRectFlags fFlags;
 257
 258     typedef SkDrawCommand INHERITED;
 259 };
 260
 261 class SkDrawDataCommand : public SkDrawCommand {
 262 public:
 263     SkDrawDataCommand(const void* data, size_t length);
 264     virtual ~SkDrawDataCommand() { delete [] fData; }
 265     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 266 private:
 267     char*  fData;
 268     size_t fLength;
 269
 270     typedef SkDrawCommand INHERITED;
 271 };
 272
 273 class SkBeginCommentGroupCommand : public SkDrawCommand {
 274 public:
 275     SkBeginCommentGroupCommand(const char* description);
 276     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 312     virtual 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     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 324     virtual 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     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 335     virtual 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     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 348     virtual 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     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 366     virtual 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     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) 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     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 444     virtual 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 SkDrawRectCommand : public SkDrawCommand {
 456 public:
 457     SkDrawRectCommand(const SkRect& rect, const SkPaint& paint);
 458     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 459
 460     const SkRect& rect() const   { return fRect; }
 461     const SkPaint& paint() const { return fPaint; }
 462 private:
 463     SkRect  fRect;
 464     SkPaint fPaint;
 465
 466     typedef SkDrawCommand INHERITED;
 467 };
 468
 469 class SkDrawRRectCommand : public SkDrawCommand {
 470 public:
 471     SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint);
 472     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 473     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 474 private:
 475     SkRRect fRRect;
 476     SkPaint fPaint;
 477
 478     typedef SkDrawCommand INHERITED;
 479 };
 480
 481 class SkDrawDRRectCommand : public SkDrawCommand {
 482 public:
 483     SkDrawDRRectCommand(const SkRRect& outer, const SkRRect& inner,
 484                         const SkPaint& paint);
 485     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 486     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 487 private:
 488     SkRRect fOuter;
 489     SkRRect fInner;
 490     SkPaint fPaint;
 491
 492     typedef SkDrawCommand INHERITED;
 493 };
 494
 495 class SkDrawSpriteCommand : public SkDrawCommand {
 496 public:
 497     SkDrawSpriteCommand(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);
 498     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 499     virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
 500 private:
 501     SkBitmap fBitmap;
 502     int      fLeft;
 503     int      fTop;
 504     SkPaint  fPaint;
 505     SkPaint* fPaintPtr;
 506
 507     typedef SkDrawCommand INHERITED;
 508 };
 509
 510 class SkDrawVerticesCommand : public SkDrawCommand {
 511 public:
 512     SkDrawVerticesCommand(SkCanvas::VertexMode vmode, int vertexCount,
 513                           const SkPoint vertices[], const SkPoint texs[],
 514                           const SkColor colors[], SkXfermode* xfermode,
 515                           const uint16_t indices[], int indexCount,
 516                           const SkPaint& paint);
 517     virtual ~SkDrawVerticesCommand();
 518     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 519 private:
 520     SkCanvas::VertexMode fVmode;
 521     int         fVertexCount;
 522     SkPoint*    fVertices;
 523     SkPoint*    fTexs;
 524     SkColor*    fColors;
 525     SkXfermode* fXfermode;
 526     uint16_t*   fIndices;
 527     int         fIndexCount;
 528     SkPaint     fPaint;
 529
 530     typedef SkDrawCommand INHERITED;
 531 };
 532
 533 class SkRotateCommand : public SkDrawCommand {
 534 public:
 535     SkRotateCommand(SkScalar degrees);
 536     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 537 private:
 538     SkScalar fDegrees;
 539
 540     typedef SkDrawCommand INHERITED;
 541 };
 542
 543 class SkSaveCommand : public SkDrawCommand {
 544 public:
 545     SkSaveCommand();
 546     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 547     virtual void trackSaveState(int* state) SK_OVERRIDE;
 548     virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; }
 549 private:
 550     typedef SkDrawCommand INHERITED;
 551 };
 552
 553 class SkSaveLayerCommand : public SkDrawCommand {
 554 public:
 555     SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
 556                        SkCanvas::SaveFlags flags);
 557     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 558     virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;
 559     virtual void trackSaveState(int* state) SK_OVERRIDE;
 560     virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; }
 561     virtual void setActive(bool active) SK_OVERRIDE { fActive = active; }
 562     virtual bool active() const SK_OVERRIDE { return fActive; }
 563
 564     const SkPaint* paint() const { return fPaintPtr; }
 565
 566 private:
 567     SkRect              fBounds;
 568     SkPaint             fPaint;
 569     SkPaint*            fPaintPtr;
 570     SkCanvas::SaveFlags fFlags;
 571
 572     bool                fActive;
 573
 574     typedef SkDrawCommand INHERITED;
 575 };
 576
 577 class SkScaleCommand : public SkDrawCommand {
 578 public:
 579     SkScaleCommand(SkScalar sx, SkScalar sy);
 580     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 581
 582     SkScalar x() const { return fSx; }
 583     SkScalar y() const { return fSy; }
 584
 585 private:
 586     SkScalar fSx;
 587     SkScalar fSy;
 588
 589     typedef SkDrawCommand INHERITED;
 590 };
 591
 592 class SkSetMatrixCommand : public SkDrawCommand {
 593 public:
 594     SkSetMatrixCommand(const SkMatrix& matrix);
 595     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 596 private:
 597     SkMatrix fMatrix;
 598
 599     typedef SkDrawCommand INHERITED;
 600 };
 601
 602 class SkSkewCommand : public SkDrawCommand {
 603 public:
 604     SkSkewCommand(SkScalar sx, SkScalar sy);
 605     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 606 private:
 607     SkScalar fSx;
 608     SkScalar fSy;
 609
 610     typedef SkDrawCommand INHERITED;
 611 };
 612
 613 class SkTranslateCommand : public SkDrawCommand {
 614 public:
 615     SkTranslateCommand(SkScalar dx, SkScalar dy);
 616     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 617
 618     SkScalar x() const { return fDx; }
 619     SkScalar y() const { return fDy; }
 620
 621 private:
 622     SkScalar fDx;
 623     SkScalar fDy;
 624
 625     typedef SkDrawCommand INHERITED;
 626 };
 627
 628 class SkPushCullCommand : public SkDrawCommand {
 629 public:
 630     SkPushCullCommand(const SkRect&);
 631     virtual void execute(SkCanvas*) SK_OVERRIDE;
 632     virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;
 633     virtual Action action() const { return kPushCull_Action; }
 634     virtual void setActive(bool active) { fActive = active; }
 635     virtual bool active() const { return fActive; }
 636 private:
 637     SkRect fCullRect;
 638     bool   fActive;
 639
 640     typedef SkDrawCommand INHERITED;
 641 };
 642
 643 class SkPopCullCommand : public SkDrawCommand {
 644 public:
 645     SkPopCullCommand();
 646     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 647     virtual Action action() const { return kPopCull_Action; }
 648 private:
 649     typedef SkDrawCommand INHERITED;
 650 };
 651
 652 #endif