Add cull rect visualization to debugger

src/utils/debugger/SkDrawCommand.h

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SKDRAWCOMMAND_H_
 #define SKDRAWCOMMAND_H_
@@ skipping 18 matching lines @@
 
     bool isVisible() const {
         return fVisible;
     }
 
     void setVisible(bool toggle) {
         fVisible = toggle;
     }
 
     SkTDArray<SkString*>* Info() {return &fInfo; };
-    virtual void execute(SkCanvas* canvas)=0;
+    virtual void execute(SkCanvas* canvas) = 0;
+    virtual void vizExecute(SkCanvas* canvas) { };
     /** Does nothing by default, but used by save() and restore()-type
         subclasses to track unresolved save() calls. */
     virtual void trackSaveState(int* state) { };
 
-    // The next "active" system is only used by save, saveLayer and restore.
-    // It is used to determine which saveLayers are currently active (at a 
+    // The next "active" system is only used by save, saveLayer, restore,
+    // pushCull and popCull. It is used in two ways:
+    // To determine which saveLayers are currently active (at a 
     // given point in the rendering).
-    //      save just return a kPush action but don't track active state
-    //      restore just return a kPop action
-    //      saveLayers return kPush but also track the active state
+    //      save just return a kPushLayer action but don't track active state
+    //      restore just return a kPopLayer action
+    //      saveLayers return kPushLayer but also track the active state
+    // To determine which culls are currently active (at a given point)
+    // in the rendering).
+    //      pushCull returns a kPushCull action
+    //      popCull  returns a kPopCull action
     enum Action {
         kNone_Action,
-        kPop_Action,
-        kPush_Action
+        kPopLayer_Action,
+        kPushLayer_Action,
+        kPopCull_Action,
+        kPushCull_Action
     };
     virtual Action action() const { return kNone_Action; }
     virtual void setActive(bool active) {}
     virtual bool active() const { return false; }
 
     DrawType getType() { return fDrawType; };
 
     virtual bool render(SkCanvas* canvas) const { return false; }
 
     static const char* GetCommandString(DrawType type);
 
 protected:
     DrawType fDrawType;
     SkTDArray<SkString*> fInfo;
 
 private:
     bool fVisible;
 };
 
 class SkRestoreCommand : public SkDrawCommand {
 public:
     SkRestoreCommand();
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual void trackSaveState(int* state) SK_OVERRIDE;
-    virtual Action action() const SK_OVERRIDE { return kPop_Action; }
+    virtual Action action() const SK_OVERRIDE { return kPopLayer_Action; }
 
 private:
     typedef SkDrawCommand INHERITED;
 };
 
 class SkClearCommand : public SkDrawCommand {
 public:
     SkClearCommand(SkColor color);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
@@ skipping 417 matching lines @@
     SkScalar fDegrees;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkSaveCommand : public SkDrawCommand {
 public:
     SkSaveCommand(SkCanvas::SaveFlags flags);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual void trackSaveState(int* state) SK_OVERRIDE;
-    virtual Action action() const SK_OVERRIDE { return kPush_Action; }
+    virtual Action action() const SK_OVERRIDE { return kPushLayer_Action; }
 private:
     SkCanvas::SaveFlags fFlags;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkSaveLayerCommand : public SkDrawCommand {
 public:
     SkSaveLayerCommand(const SkRect* bounds, const SkPaint* paint,
                        SkCanvas::SaveFlags flags);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
+    virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;
     virtual void trackSaveState(int* state) SK_OVERRIDE;
-    virtual Action action() const SK_OVERRIDE{ return kPush_Action; }
+    virtual Action action() const SK_OVERRIDE{ return kPushLayer_Action; }
     virtual void setActive(bool active) SK_OVERRIDE { fActive = active; }
     virtual bool active() const SK_OVERRIDE { return fActive; }
 
     const SkPaint* paint() const { return fPaintPtr; }
 
 private:
     SkRect              fBounds;
     SkPaint             fPaint;
     SkPaint*            fPaintPtr;
     SkCanvas::SaveFlags fFlags;
@@ skipping 51 matching lines @@
     SkScalar fDx;
     SkScalar fDy;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkPushCullCommand : public SkDrawCommand {
 public:
     SkPushCullCommand(const SkRect&);
     virtual void execute(SkCanvas*) SK_OVERRIDE;
-
+    virtual void vizExecute(SkCanvas* canvas) SK_OVERRIDE;
+    virtual Action action() const { return kPushCull_Action; }
+    virtual void setActive(bool active) { fActive = active; }
+    virtual bool active() const { return fActive; }
 private:
     SkRect fCullRect;
+    bool   fActive;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class SkPopCullCommand : public SkDrawCommand {
 public:
     SkPopCullCommand();
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-
+    virtual Action action() const { return kPopCull_Action; }
 private:
     typedef SkDrawCommand INHERITED;
 };
 
 #endif