abstract name of clipping ops, to transtion to a more restricted set

include/core/SkClipStack.h

-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #ifndef SkClipStack_DEFINED
 #define SkClipStack_DEFINED
 
+#include "SkCanvas.h"
 #include "SkDeque.h"
 #include "SkPath.h"
 #include "SkRect.h"
 #include "SkRRect.h"
 #include "SkRegion.h"
 #include "SkTLazy.h"
 
 class SkCanvasClipVisitor;
 
 // Because a single save/restore state can have multiple clips, this class
@@ skipping 25 matching lines @@
             //!< This element combines a round-rect with the current clip using a set operation
             kRRect_Type,
             //!< This element combines a path with the current clip using a set operation
             kPath_Type,
 
             kLastType = kPath_Type
         };
         static const int kTypeCnt = kLastType + 1;
 
         Element() {
-            this->initCommon(0, SkRegion::kReplace_Op, false);
+            this->initCommon(0, SkCanvas::kReplace_Op, false);
             this->setEmpty();
         }
 
         Element(const Element&);
 
-        Element(const SkRect& rect, SkRegion::Op op, bool doAA) {
+        Element(const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
             this->initRect(0, rect, op, doAA);
         }
 
-        Element(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        Element(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
             this->initRRect(0, rrect, op, doAA);
         }
 
-        Element(const SkPath& path, SkRegion::Op op, bool doAA) {
+        Element(const SkPath& path, SkCanvas::ClipOp op, bool doAA) {
             this->initPath(0, path, op, doAA);
         }
 
         bool operator== (const Element& element) const;
         bool operator!= (const Element& element) const { return !(*this == element); }
 
         //!< Call to get the type of the clip element.
         Type getType() const { return fType; }
 
         //!< Call to get the save count associated with this clip element.
         int getSaveCount() const { return fSaveCount; }
 
         //!< Call if getType() is kPath to get the path.
         const SkPath& getPath() const { SkASSERT(kPath_Type == fType); return *fPath.get(); }
 
         //!< Call if getType() is kRRect to get the round-rect.
         const SkRRect& getRRect() const { SkASSERT(kRRect_Type == fType); return fRRect; }
 
         //!< Call if getType() is kRect to get the rect.
         const SkRect& getRect() const {
             SkASSERT(kRect_Type == fType && (fRRect.isRect() || fRRect.isEmpty()));
             return fRRect.getBounds();
         }
 
         //!< Call if getType() is not kEmpty to get the set operation used to combine this element.
-        SkRegion::Op getOp() const { return fOp; }
+        SkCanvas::ClipOp getOp() const { return fOp; }
 
         //!< Call to get the element as a path, regardless of its type.
         void asPath(SkPath* path) const;
 
         //!< Call if getType() is not kPath to get the element as a round rect.
         const SkRRect& asRRect() const { SkASSERT(kPath_Type != fType); return fRRect; }
 
         /** If getType() is not kEmpty this indicates whether the clip shape should be anti-aliased
             when it is rasterized. */
         bool isAA() const { return fDoAA; }
 
         //!< Inverts the fill of the clip shape. Note that a kEmpty element remains kEmpty.
         void invertShapeFillType();
 
         //!< Sets the set operation represented by the element.
-        void setOp(SkRegion::Op op) { fOp = op; }
+        void setOp(SkCanvas::ClipOp op) { fOp = op; }
 
         /** The GenID can be used by clip stack clients to cache representations of the clip. The
             ID corresponds to the set of clip elements up to and including this element within the
             stack not to the element itself. That is the same clip path in different stacks will
             have a different ID since the elements produce different clip result in the context of
             their stacks. */
         int32_t getGenID() const { SkASSERT(kInvalidGenID != fGenID); return fGenID; }
 
         /**
          * Gets the bounds of the clip element, either the rect or path bounds. (Whether the shape
@@ skipping 71 matching lines @@
          */
         void dump() const;
 #endif
 
     private:
         friend class SkClipStack;
 
         SkTLazy<SkPath> fPath;
         SkRRect         fRRect;
         int             fSaveCount; // save count of stack when this element was added.
-        SkRegion::Op    fOp;
+        SkCanvas::ClipOp fOp;
         Type            fType;
         bool            fDoAA;
 
         /* fFiniteBoundType and fFiniteBound are used to incrementally update the clip stack's
            bound. When fFiniteBoundType is kNormal_BoundsType, fFiniteBound represents the
            conservative bounding box of the pixels that aren't clipped (i.e., any pixels that can be
            drawn to are inside the bound). When fFiniteBoundType is kInsideOut_BoundsType (which
            occurs when a clip is inverse filled), fFiniteBound represents the conservative bounding
            box of the pixels that _are_ clipped (i.e., any pixels that cannot be drawn to are inside
            the bound). When fFiniteBoundType is kInsideOut_BoundsType the actual bound is the
            infinite plane. This behavior of fFiniteBoundType and fFiniteBound is required so that we
            can capture the cancelling out of the extensions to infinity when two inverse filled
            clips are Booleaned together. */
         SkClipStack::BoundsType fFiniteBoundType;
         SkRect                  fFiniteBound;
 
         // When element is applied to the previous elements in the stack is the result known to be
         // equivalent to a single rect intersection? IIOW, is the clip effectively a rectangle.
         bool                    fIsIntersectionOfRects;
 
         int                     fGenID;
 
         Element(int saveCount) {
-            this->initCommon(saveCount, SkRegion::kReplace_Op, false);
+            this->initCommon(saveCount, SkCanvas::kReplace_Op, false);
             this->setEmpty();
         }
 
-        Element(int saveCount, const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        Element(int saveCount, const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
             this->initRRect(saveCount, rrect, op, doAA);
         }
 
-        Element(int saveCount, const SkRect& rect, SkRegion::Op op, bool doAA) {
+        Element(int saveCount, const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
             this->initRect(saveCount, rect, op, doAA);
         }
 
-        Element(int saveCount, const SkPath& path, SkRegion::Op op, bool doAA) {
+        Element(int saveCount, const SkPath& path, SkCanvas::ClipOp op, bool doAA) {
             this->initPath(saveCount, path, op, doAA);
         }
 
-        void initCommon(int saveCount, SkRegion::Op op, bool doAA) {
+        void initCommon(int saveCount, SkCanvas::ClipOp op, bool doAA) {
             fSaveCount = saveCount;
             fOp = op;
             fDoAA = doAA;
             // A default of inside-out and empty bounds means the bounds are effectively void as it
             // indicates that nothing is known to be outside the clip.
             fFiniteBoundType = kInsideOut_BoundsType;
             fFiniteBound.setEmpty();
             fIsIntersectionOfRects = false;
             fGenID = kInvalidGenID;
         }
 
-        void initRect(int saveCount, const SkRect& rect, SkRegion::Op op, bool doAA) {
+        void initRect(int saveCount, const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
             fRRect.setRect(rect);
             fType = kRect_Type;
             this->initCommon(saveCount, op, doAA);
         }
 
-        void initRRect(int saveCount, const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        void initRRect(int saveCount, const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
             SkRRect::Type type = rrect.getType();
             fRRect = rrect;
             if (SkRRect::kRect_Type == type || SkRRect::kEmpty_Type == type) {
                 fType = kRect_Type;
             } else {
                 fType = kRRect_Type;
             }
             this->initCommon(saveCount, op, doAA);
         }
 
-        void initPath(int saveCount, const SkPath& path, SkRegion::Op op, bool doAA);
+        void initPath(int saveCount, const SkPath& path, SkCanvas::ClipOp op, bool doAA);
 
         void setEmpty();
 
         // All Element methods below are only used within SkClipStack.cpp
         inline void checkEmpty() const;
-        inline bool canBeIntersectedInPlace(int saveCount, SkRegion::Op op) const;
+        inline bool canBeIntersectedInPlace(int saveCount, SkCanvas::ClipOp op) const;
         /* This method checks to see if two rect clips can be safely merged into one. The issue here
           is that to be strictly correct all the edges of the resulting rect must have the same
           anti-aliasing. */
         bool rectRectIntersectAllowed(const SkRect& newR, bool newAA) const;
         /** Determines possible finite bounds for the Element given the previous element of the
             stack */
         void updateBoundAndGenID(const Element* prior);
         // The different combination of fill & inverse fill when combining bounding boxes
         enum FillCombo {
             kPrev_Cur_FillCombo,
@@ skipping 50 matching lines @@
     bool quickContains(const SkRRect& devRRect) const {
         return this->isWideOpen() || this->internalQuickContains(devRRect);
     }
 
     /**
      * Flattens the clip stack into a single SkPath. Returns true if any of
      * the clip stack components requires anti-aliasing.
      */
     bool asPath(SkPath* path) const;
 
-    void clipDevRect(const SkIRect& ir, SkRegion::Op op) {
+    void clipDevRect(const SkIRect& ir, SkCanvas::ClipOp op) {
         SkRect r;
         r.set(ir);
         this->clipDevRect(r, op, false);
     }
-    void clipDevRect(const SkRect&, SkRegion::Op, bool doAA);
-    void clipDevRRect(const SkRRect&, SkRegion::Op, bool doAA);
-    void clipDevPath(const SkPath&, SkRegion::Op, bool doAA);
+    void clipDevRect(const SkRect&, SkCanvas::ClipOp, bool doAA);
+    void clipDevRRect(const SkRRect&, SkCanvas::ClipOp, bool doAA);
+    void clipDevPath(const SkPath&, SkCanvas::ClipOp, bool doAA);
     // An optimized version of clipDevRect(emptyRect, kIntersect, ...)
     void clipEmpty();
 
     /**
      * isWideOpen returns true if the clip state corresponds to the infinite
      * plane (i.e., draws are not limited at all)
      */
     bool isWideOpen() const { return this->getTopmostGenID() == kWideOpenGenID; }
 
     /**
@@ skipping 50 matching lines @@
          *  Return the clip element for this iterator. If next()/prev() returns NULL, then the
          *  iterator is done.
          */
         const Element* next();
         const Element* prev();
 
         /**
          * Moves the iterator to the topmost element with the specified RegionOp and returns that
          * element. If no clip element with that op is found, the first element is returned.
          */
-        const Element* skipToTopmost(SkRegion::Op op);
+        const Element* skipToTopmost(SkCanvas::ClipOp op);
 
         /**
          * Restarts the iterator on a clip stack.
          */
         void reset(const SkClipStack& stack, IterStart startLoc);
 
     private:
         const SkClipStack* fStack;
         SkDeque::Iter      fIter;
     };
@@ skipping 73 matching lines @@
      */
     void restoreTo(int saveCount);
 
     /**
      * Return the next unique generation ID.
      */
     static int32_t GetNextGenID();
 };
 
 #endif