Make SkPath::isOval() and SkPath::isRRect return the orientation and starting index.

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
 #define SkPath_DEFINED
 
 #include "SkMatrix.h"
 #include "SkPathRef.h"
 #include "SkRefCnt.h"
 
 class SkReader32;
 class SkWriter32;
 class SkAutoPathBoundsUpdate;
 class SkString;
 class SkRRect;
 class SkWStream;
 
 /** \class SkPath
 
     The SkPath class encapsulates compound (multiple contour) geometric paths
     consisting of straight line segments, quadratic curves, and cubic curves.
 */
 class SK_API SkPath {
 public:
+    enum Direction {
+        /** clockwise direction for adding closed contours */
+        kCW_Direction,
+        /** counter-clockwise direction for adding closed contours */
+        kCCW_Direction,
+    };
+
     SkPath();
     SkPath(const SkPath&);
     ~SkPath();
 
     SkPath& operator=(const SkPath&);
     friend  SK_API bool operator==(const SkPath&, const SkPath&);
     friend bool operator!=(const SkPath& a, const SkPath& b) {
         return !(a == b);
     }
 
@@ skipping 120 matching lines @@
      */
     SK_ATTR_DEPRECATED("use setConvexity")
     void setIsConvex(bool isConvex) {
         this->setConvexity(isConvex ? kConvex_Convexity : kConcave_Convexity);
     }
 
     /** 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.
-     *
+     * @param dir       is the oval CCW (or CW if false).
+     * @param start     indicates where the contour starts on the oval (see
+     *                  SkPath::addOval for intepretation of the index).
      * @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 { return fPathRef->isOval(rect); }
+    bool isOval(SkRect* rect, Direction* dir = nullptr,
+                unsigned* start = nullptr) const {
+        bool isCCW;
+        bool result = fPathRef->isOval(rect, &isCCW, start);
+        if (dir && result) {
+            *dir = isCCW ? kCCW_Direction : kCW_Direction;
+        }
+        return result;
+    }
 
     /** Returns true if the path is a round rect.
      *
      * @param rrect  Returns the bounding rect and radii of this round rect.
+     * @param dir    is the rrect CCW (or CW if false).
+     * @param start  indicates where the contour starts on the rrect (see
+     *               SkPath::addRRect for intepretation of the index).
      *
      * @return true if this path is a round rect.
      *              Tracking whether a path is a round rect is considered an
      *              optimization for performance and so some paths that are in
      *              fact round rects can report false.
      */
-    bool isRRect(SkRRect* rrect) const { return fPathRef->isRRect(rrect); }
+    bool isRRect(SkRRect* rrect, Direction* dir = nullptr,
+                 unsigned* start = nullptr) const {
+        bool isCCW;
+        bool result = fPathRef->isRRect(rrect, &isCCW, start);
+        if (dir && result) {
+            *dir = isCCW ? kCCW_Direction : kCW_Direction;
+        }
+        return result;
+    }
 
     /** 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 322 matching lines @@
         this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
     }
 
     enum ArcSize {
         /** the smaller of the two possible SVG arcs. */
         kSmall_ArcSize,
         /** the larger of the two possible SVG arcs. */
         kLarge_ArcSize,
     };
 
-    enum Direction {
-        /** clockwise direction for adding closed contours */
-        kCW_Direction,
-        /** counter-clockwise direction for adding closed contours */
-        kCCW_Direction,
-    };
-
     /**
      *  Append an elliptical arc from the current point in the format used by SVG.
      *  The center of the ellipse is computed to satisfy the constraints below.
      *
      *  @param rx,ry The radii in the x and y directions respectively.
      *  @param xAxisRotate The angle in degrees relative to the x-axis.
      *  @param largeArc Determines whether the smallest or largest arc possible
      *         is drawn.
      *  @param sweep Determines if the arc should be swept in an anti-clockwise or
      *         clockwise direction. Note that this enum value is opposite the SVG
@@ skipping 164 matching lines @@
      *       -*-
      *     |     |
      *   3 *     * 1
      *     |     |
      *       -*-
      *        2
      */
     void addOval(const SkRect& oval, Direction dir, unsigned start);
 
     /**
-     *  Add a closed circle contour to the path
+     *  Add a closed circle contour to the path. The circle contour begins at
+     *  the right-most point (as though 1 were passed to addOval's 'start' param).
      *
      *  @param x        The x-coordinate of the center of a circle to add as a
      *                  closed contour to the path
      *  @param y        The y-coordinate of the center of a circle to add as a
      *                  closed contour to the path
      *  @param radius   The radius of a circle to add as a closed contour to the
      *                  path
      *  @param dir  The direction to wind the circle's contour.
      */
     void addCircle(SkScalar x, SkScalar y, SkScalar radius,
@@ skipping 436 matching lines @@
 
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test reversePathTo
     friend class PathTest_Private; // unit test reversePathTo
     friend class ForceIsRRect_Private; // unit test isRRect
 };
 
 #endif