Move more of SkPath into SkPathRef

include/core/SkPath.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 SkPath_DEFINED
@@ skipping 75 matching lines @@
     /** Returns true if the filltype is one of the Inverse variants */
     bool isInverseFillType() const { return IsInverseFillType((FillType)fFillType); }
 
     /**
      *  Toggle between inverse and normal filltypes. This reverse the return
      *  value of isInverseFillType()
      */
     void toggleInverseFillType() {
         fFillType ^= 2;
         GEN_ID_INC;
-     }
+    }
 
     enum Convexity {
         kUnknown_Convexity,
         kConvex_Convexity,
         kConcave_Convexity
     };
 
     /**
      *  Return the path's convexity, as stored in the path. If it is currently unknown,
      *  then this function will attempt to compute the convexity (and cache the result).
      */
     Convexity getConvexity() const {
-        if (kUnknown_Convexity != fConvexity) {
-            return static_cast<Convexity>(fConvexity);
-        } else {
-            return this->internalGetConvexity();
-        }
+        return static_cast<Convexity>(fPathRef->getConvexity());
     }
 
     /**
      *  Return the currently cached value for convexity, even if that is set to
      *  kUnknown_Convexity. Note: getConvexity() will automatically call
      *  ComputeConvexity and cache its return value if the current setting is
      *  kUnknown.
      */
-    Convexity getConvexityOrUnknown() const { return (Convexity)fConvexity; }
+    Convexity getConvexityOrUnknown() const { 
+        return static_cast<Convexity>(fPathRef->getConvexityOrUnknown());
+    }
 
     /**
      *  Store a convexity setting in the path. There is no automatic check to
      *  see if this value actually agrees with the return value that would be
      *  computed by getConvexity().
      *
      *  Note: even if this is set to a "known" value, if the path is later
      *  changed (e.g. lineTo(), addRect(), etc.) then the cached value will be
      *  reset to kUnknown_Convexity.
      */
@@ skipping 22 matching lines @@
     /** Returns true if the path is an oval.
      *
      * @param rect      returns the bounding rect of this oval. It's a circle
      *                  if the height and width are the same.
      *
      * @return true if this path is an oval.
      *              Tracking whether a path is an oval is considered an
      *              optimization for performance and so some paths that are in
      *              fact ovals can report false.
      */
-    bool isOval(SkRect* rect) const;
+    bool isOval(SkRect* rect) const { return fPathRef->isOval(rect); }
 
     /** Clear any lines and curves from the path, making it empty. This frees up
         internal storage associated with those segments.
         On Android, does not change fSourcePath.
     */
     void reset();
 
     /** Similar to reset(), in that all lines and curves are removed from the
         path. However, any internal storage for those lines/curves is retained,
         making reuse of the path potentially faster.
@@ skipping 274 matching lines @@
                 this contour, to specify the 1st control point of a cubic curve
         @param dx2   The amount to add to the x-coordinate of the last point on
                 this contour, to specify the 2nd control point of a cubic curve
         @param dy2   The amount to add to the y-coordinate of the last point on
                 this contour, to specify the 2nd control point of a cubic curve
         @param dx3   The amount to add to the x-coordinate of the last point on
                      this contour, to specify the end point of a cubic curve
         @param dy3   The amount to add to the y-coordinate of the last point on
                      this contour, to specify the end point of a cubic curve
     */
-    void    rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
-                     SkScalar x3, SkScalar y3);
+    void rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
+                  SkScalar x3, SkScalar y3);
 
     /** Append the specified arc to the path as a new contour. If the start of
         the path is different from the path's current last point, then an
         automatic lineTo() is added to connect the current contour to the start
         of the arc. However, if the path is empty, then we call moveTo() with
         the first point of the arc. The sweep angle is treated mod 360.
 
         @param oval The bounding oval defining the shape and size of the arc
         @param startAngle Starting angle (in degrees) where the arc begins
         @param sweepAngle Sweep angle (in degrees) measured clockwise. This is
                           treated mod 360.
         @param forceMoveTo If true, always begin a new contour with the arc
     */
-    void    arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
-                  bool forceMoveTo);
+    void arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
+               bool forceMoveTo);
 
     /** Append a line and arc to the current path. This is the same as the
         PostScript call "arct".
     */
     void arcTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                SkScalar radius);
 
     /** Append a line and arc to the current path. This is the same as the
         PostScript call "arct".
     */
@@ skipping 58 matching lines @@
         return (FillType)(fill & 1);
     }
 
     /**
      *  Tries to quickly compute the direction of the first non-degenerate
      *  contour. If it can be computed, return true and set dir to that
      *  direction. If it cannot be (quickly) determined, return false and ignore
      *  the dir parameter. If the direction was determined, it is cached to make
      *  subsequent calls return quickly.
      */
-    bool cheapComputeDirection(Direction* dir) const;
+    bool cheapComputeDirection(Direction* dir) const {
+        bool result;
+        if (NULL != dir) {
+            int intDir = *dir;
+            result = fPathRef->cheapComputeDirection(&intDir);
+            *dir = static_cast<Direction>(intDir);
+        } else {
+            result = fPathRef->cheapComputeDirection(NULL);
+        }
+        return result;
+    }
 
     /**
      *  Returns true if the path's direction can be computed via
      *  cheapComputDirection() and if that computed direction matches the
      *  specified direction. If dir is kUnknown, returns true if the direction
      *  cannot be computed.
      */
     bool cheapIsDirection(Direction dir) const {
         Direction computedDir = kUnknown_Direction;
         (void)this->cheapComputeDirection(&computedDir);
@@ skipping 216 matching lines @@
         kQuad_SegmentMask   = 1 << 1,
         kConic_SegmentMask  = 1 << 2,
         kCubic_SegmentMask  = 1 << 3,
     };
 
     /**
      *  Returns a mask, where each bit corresponding to a SegmentMask is
      *  set if the path contains 1 or more segments of that type.
      *  Returns 0 for an empty path (no segments).
      */
-    uint32_t getSegmentMasks() const { return fSegmentMask; }
+    uint32_t getSegmentMasks() const { return fPathRef->getSegmentMasks(); }
 
     enum Verb {
         kMove_Verb,     //!< iter.next returns 1 point
         kLine_Verb,     //!< iter.next returns 2 points
         kQuad_Verb,     //!< iter.next returns 3 points
         kConic_Verb,    //!< iter.next returns 3 points + iter.conicWeight()
         kCubic_Verb,    //!< iter.next returns 4 points
         kClose_Verb,    //!< iter.next returns 1 point (contour's moveTo pt)
         kDone_Verb,     //!< iter.next returns 0 points
     };
 
     /** Iterate through all of the segments (lines, quadratics, cubics) of
         each contours in a path.
 
         The iterator cleans up the segments along the way, removing degenerate
         segments and adding close verbs where necessary. When the forceClose
         argument is provided, each contour (as defined by a new starting
         move command) will be completed with a close verb regardless of the
         contour's contents.
     */
     class SK_API Iter {
     public:
         Iter();
         Iter(const SkPath&, bool forceClose);
+        Iter(const SkPathRef*, bool forceClose);
 
         void setPath(const SkPath&, bool forceClose);
+        void setPathRef(const SkPathRef*, bool forceClose);
 
         /** Return the next verb in this iteration of the path. When all
             segments have been visited, return kDone_Verb.
 
             @param  pts The points representing the current verb and/or segment
             @param doConsumeDegerates If true, first scan for segments that are
                    deemed degenerate (too short) and skip those.
             @return The verb for the current segment
         */
         Verb next(SkPoint pts[4], bool doConsumeDegerates = true) {
@@ skipping 96 matching lines @@
     const SkPath* getSourcePath() const;
     void setSourcePath(const SkPath* path);
 #endif
 
     SkDEBUGCODE(void validate() const;)
 
 private:
     enum SerializationOffsets {
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
         kNewFormat_SerializationShift = 28, // requires 1 bit
+        kOldDirection_SerializationShift = 26, // requires 2 bits
+        kOldIsFinite_SerializationShift = 25,    // 1 bit
+        kOldIsOval_SerializationShift = 24,    // requires 1 bit
+        kOldConvexity_SerializationShift = 16, // requires 8 bits
+#endif  
+        // TODO: make this shift be 0
+        kFillType_SerializationShift = 8,   // requires 8 bits
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+        kOldSegmentMask_SerializationShift = 0 // requires 4 bits
 #endif
-        kDirection_SerializationShift = 26, // requires 2 bits
-#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
-        // rename to kUnused_SerializationShift
-        kOldIsFinite_SerializationShift = 25,    // 1 bit
-#endif
-        kIsOval_SerializationShift = 24,    // requires 1 bit
-        kConvexity_SerializationShift = 16, // requires 8 bits
-        kFillType_SerializationShift = 8,   // requires 8 bits
-        kSegmentMask_SerializationShift = 0 // requires 4 bits
     };
 
     SkAutoTUnref<SkPathRef> fPathRef;
 
-    int                 fLastMoveToIndex;
     uint8_t             fFillType;
-    uint8_t             fSegmentMask;
-    mutable uint8_t     fConvexity;
-    mutable uint8_t     fDirection;
-    mutable SkBool8     fIsOval;
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t            fGenerationID;
     const SkPath*       fSourcePath;
 #endif
 
     /** Resets all fields other than fPathRef to their initial 'empty' values.
      *  Assumes the caller has already emptied fPathRef.
      *  On Android increments fGenerationID without reseting it.
      */
     void resetFields();
@@ skipping 12 matching lines @@
         automatically set to (0,0).
     */
     void pathTo(const SkPath& path);
 
     /*  Append, in reverse order, the first contour of path, ignoring path's
         last point. If no moveTo() call has been made for this contour, the
         first point is automatically set to (0,0).
     */
     void reversePathTo(const SkPath&);
 
-    // called before we add points for lineTo, quadTo, cubicTo, checking to see
-    // if we need to inject a leading moveTo first
-    //
-    //  SkPath path; path.lineTo(...);   <--- need a leading moveTo(0, 0)
-    // SkPath path; ... path.close(); path.lineTo(...) <-- need a moveTo(previous moveTo)
-    //
-    inline void injectMoveToIfNeeded();
-
     inline bool hasOnlyMoveTos() const;
 
-    Convexity internalGetConvexity() const;
-
     bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts,
                        bool* isClosed, Direction* direction) const;
 
     /** Returns if the path can return a bound at no cost (true) or will have to
         perform some computation (false).
      */
     bool hasComputedBounds() const {
         SkDEBUGCODE(this->validate();)
         return fPathRef->hasComputedBounds();
     }
 
-
-    // 'rect' needs to be sorted
-    void setBounds(const SkRect& rect) {
-        fPathRef->setBounds(rect);
-    }
-
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
     friend class SkPathRef;     // just for SerializationOffsets
 #endif
     friend class SkAutoPathBoundsUpdate;
-    friend class SkAutoDisableOvalCheck;
-    friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test pathTo/reversePathTo
 };
 
 #endif