use ClipOp instead of SkRegion for clipping

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkClipStack.h"
 #include "SkPaint.h"
 #include "SkRefCnt.h"
 #include "SkPath.h"
 #include "SkRegion.h"
 #include "SkSurfaceProps.h"
 #include "SkXfermode.h"
 
+// Undefine this when we change callers to use SkClipOp or legacyClip (temporarily)
+//#define SK_SUPPORT_REGION_CLIPOPS
+
+// Undefine this when we have updated all callers to SkClipOp
+#define SK_SUPPORT_LEGACY_CLIPOPS
+
 #ifdef SK_SUPPORT_LEGACY_DRAWTEXT_VIRTUAL
     #define SK_LEGACY_DRAWTEXT_VIRTUAL  virtual
 #else
     #define SK_LEGACY_DRAWTEXT_VIRTUAL
 #endif
 
 class SkBaseDevice;
 class SkCanvasClipVisitor;
 class SkCanvasDrawable;
 class SkDraw;
 class SkDrawFilter;
 class SkImage;
 class SkMetaData;
 class SkPicture;
 class SkRRect;
 class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 class GrContext;
 class GrRenderTarget;
 
 class SkCanvasState;
 
+enum SkClipOp {
+    kIntersect_SkClipOp,
+    kDifference_SkClipOp,
+};
+
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
     This includes a reference to the device itself, and a stack of matrix/clip
     values. For any given draw call (e.g. drawRect), the geometry of the object
     being drawn is transformed by the concatenation of all the matrices in the
     stack. The transformed geometry is clipped by the intersection of all of
     the clips in the stack.
 
     While the Canvas holds the state of the drawing device, the state (style)
@@ skipping 407 matching lines @@
 
     /** Replace the current matrix with a copy of the specified matrix.
         @param matrix The matrix that will be copied into the current matrix.
     */
     void setMatrix(const SkMatrix& matrix);
 
     /** Helper for setMatrix(identity). Sets the current matrix to identity.
     */
     void resetMatrix();
 
+#ifndef SK_SUPPORT_REGION_CLIPOPS
+private:
+#endif
+    void clipRect(const SkRect&, SkRegion::Op, bool doAntiAlias = false);
+    void clipRRect(const SkRRect&, SkRegion::Op, bool doAntiAlias = false);
+    void clipPath(const SkPath&, SkRegion::Op, bool doAntiAlias = false);
+    void clipRegion(const SkRegion&, SkRegion::Op);
+#ifndef SK_SUPPORT_REGION_CLIPOPS
+public:
+#endif
+
+/*  These support SkRegion ops, and are used in the interim until we can remove all
+ *  needs for these ops. When all callers only need Intersect or Difference, we will
+ *  remove these calls.
+ */
+#ifdef SK_SUPPORT_LEGACY_CLIPOPS
+    void legacyClipRect(const SkRect& rect, SkRegion::Op op, bool doAntiAlias = false) {
+        this->clipRect(rect, op, doAntiAlias);
+    }
+    void legacyClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAntiAlias = false) {
+        this->clipRRect(rrect, op, doAntiAlias);
+    }
+    void legacyClipPath(const SkPath& path, SkRegion::Op op, bool doAntiAlias = false) {
+        this->clipPath(path, op, doAntiAlias);
+    }
+    void legacyClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
+        this->clipRegion(deviceRgn, op);
+    }
+#endif
+
     /**
      *  Modify the current clip with the specified rectangle.
      *  @param rect The rect to combine with the current clip
-     *  @param op The region op to apply to the current clip
+     *  @param op The ClipOp to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
-    void clipRect(const SkRect& rect,
-                  SkRegion::Op op = SkRegion::kIntersect_Op,
-                  bool doAntiAlias = false);
+    void clipRect(const SkRect& rect, SkClipOp op, bool doAntiAlias = false);
+    void clipRect(const SkRect& rect) {
+        this->clipRect(rect, kIntersect_SkClipOp, false);
+    }
 
     /**
      *  Modify the current clip with the specified SkRRect.
      *  @param rrect The rrect to combine with the current clip
-     *  @param op The region op to apply to the current clip
+     *  @param op The ClipOp to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
-    void clipRRect(const SkRRect& rrect,
-                   SkRegion::Op op = SkRegion::kIntersect_Op,
-                   bool doAntiAlias = false);
+    void clipRRect(const SkRRect& rrect, SkClipOp op, bool doAntiAlias = false);
+    void clipRRect(const SkRRect& rrect) {
+        this->clipRRect(rrect, kIntersect_SkClipOp, false);
+    }
 
     /**
      *  Modify the current clip with the specified path.
      *  @param path The path to combine with the current clip
-     *  @param op The region op to apply to the current clip
+     *  @param op The ClipOp to apply to the current clip
      *  @param doAntiAlias true if the clip should be antialiased
      */
-    void clipPath(const SkPath& path,
-                  SkRegion::Op op = SkRegion::kIntersect_Op,
-                  bool doAntiAlias = false);
+    void clipPath(const SkPath& path, SkClipOp op, bool doAntiAlias = false);
+    void clipPath(const SkPath& path) {
+        this->clipPath(path, kIntersect_SkClipOp, false);
+    }
 
     /** EXPERIMENTAL -- only used for testing
         Set to false to force clips to be hard, even if doAntiAlias=true is
         passed to clipRect or clipPath.
      */
     void setAllowSoftClip(bool allow) {
         fAllowSoftClip = allow;
     }
 
     /** EXPERIMENTAL -- only used for testing
         Set to simplify clip stack using path ops.
      */
     void setAllowSimplifyClip(bool allow) {
         fAllowSimplifyClip = allow;
     }
 
     /** Modify the current clip with the specified region. Note that unlike
         clipRect() and clipPath() which transform their arguments by the current
         matrix, clipRegion() assumes its argument is already in device
         coordinates, and so no transformation is performed.
         @param deviceRgn    The region to apply to the current clip
-        @param op The region op to apply to the current clip
+        @param op The ClipOp to apply to the current clip
     */
-    void clipRegion(const SkRegion& deviceRgn,
-                    SkRegion::Op op = SkRegion::kIntersect_Op);
+    void clipRegion(const SkRegion& deviceRgn, SkClipOp op = kIntersect_SkClipOp);
 
     /** Helper for clipRegion(rgn, kReplace_Op). Sets the current clip to the
         specified region. This does not intersect or in any other way account
         for the existing clip region.
         @param deviceRgn The region to copy into the current clip.
     */
     void setClipRegion(const SkRegion& deviceRgn) {
-        this->clipRegion(deviceRgn, SkRegion::kReplace_Op);
+        this->legacyClipRegion(deviceRgn, SkRegion::kReplace_Op);
     }
 
     /** Return true if the specified rectangle, after being transformed by the
         current matrix, would lie completely outside of the current clip. Call
         this to check if an area you intend to draw into is clipped out (and
         therefore you can skip making the draw calls).
         @param rect the rect to compare with the current clip
         @return true if the rect (transformed by the canvas' matrix) does not
                      intersect with the canvas' clip
     */
@@ skipping 995 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
 };
 
 #endif