add rect-output parameter to isRect, allowing us to return the correct bounds even if a rectagular …

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 218 matching lines @@
     }
 
     /**
      *  Returns true if the path specifies a single line (i.e. it contains just
      *  a moveTo and a lineTo). If so, and line[] is not null, it sets the 2
      *  points in line[] to the end-points of the line. If the path is not a
      *  line, returns false and ignores line[].
      */
     bool isLine(SkPoint line[2]) const;
 
+    enum Direction {
+        /** Direction either has not been or could not be computed */
+        kUnknown_Direction,
+        /** clockwise direction for adding closed contours */
+        kCW_Direction,
+        /** counter-clockwise direction for adding closed contours */
+        kCCW_Direction,
+    };
+    
     /** Returns true if the path specifies a rectangle. If so, and if rect is
         not null, set rect to the bounds of the path. If the path does not
         specify a rectangle, return false and ignore rect.
 
         @param rect If not null, returns the bounds of the path if it specifies
                     a rectangle
         @return true if the path specifies a rectangle
     */
-    bool isRect(SkRect* rect) const;
+    bool isRect(SkRect* rect) const {
+        return this->isRect(rect, NULL, NULL);
+    }
+    
+    /**
+     *  Returns true if the path specifies a rectangle.
+     *
+     *  If this returns false, then all output parameters are ignored, and left
+     *  unchanged. If this returns true, then each of the output parameters
+     *  are checked for NULL. If they are not, they return their value.
+     *
+     *  @param rect If not null, set to the bounds of the rectangle
+     *  @param isClosed If not null, set to true if the path is closed
+     *  @param direction If not null, set to the rectangle's direction
+     *  @return true if the path specifies a rectangle
+     */
+    bool isRect(SkRect* rect, bool* isClosed, Direction* direction) const;

[Stephen Chennney, 2013/06/21 17:19:05]

Is isClosed implied by a true return value? On other words, can something not
closed be a rect?

[reed1, 2013/06/21 17:24:03]

move line line line line

that path is not closed, even if the move and final line specify the same
coordinate. isClosed has meaning when we stroke things: do I add two 'caps' or
one 'join' for that 4th corner. Thus we can return true and isClosed can be
either value.

For clients that intend to "fill" the path, they can ignore the isClosed value,
since it will fill the same way w/ or w/o a 'close' verb.

+    
+    /** Returns true if the path specifies a pair of nested rectangles. If so, and if
+     rect is not null, set rect[0] to the outer rectangle and rect[1] to the inner
+     rectangle. If so, and dirs is not null, set dirs[0] to the direction of
+     the outer rectangle and dirs[1] to the direction of the inner rectangle. If
+     the path does not specify a pair of nested rectangles, return
+     false and ignore rect and dirs.
+     
+     @param rect If not null, returns the path as a pair of nested rectangles
+     @param dirs If not null, returns the direction of the rects
+     @return true if the path describes a pair of nested rectangles
+     */
+    bool isNestedRects(SkRect rect[2], Direction dirs[2] = NULL) const;
 
     /** Return the number of points in the path
      */
     int countPoints() const;
 
     /** Return the point at the specified index. If the index is out of range
          (i.e. is not 0 <= index < countPoints()) then the returned coordinates
          will be (0,0)
      */
     SkPoint getPoint(int index) const;
@@ skipping 235 matching lines @@
     */
     void arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius) {
         this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
     }
 
     /** Close the current contour. If the current point is not equal to the
         first point of the contour, a line segment is automatically added.
     */
     void close();
 
-    enum Direction {
-        /** Direction either has not been or could not be computed */
-        kUnknown_Direction,
-        /** clockwise direction for adding closed contours */
-        kCW_Direction,
-        /** counter-clockwise direction for adding closed contours */
-        kCCW_Direction,
-    };
-
     /**
      *  Return the opposite of the specified direction. kUnknown is its own
      *  opposite.
      */
     static Direction OppositeDirection(Direction dir) {
         static const Direction gOppositeDir[] = {
             kUnknown_Direction, kCCW_Direction, kCW_Direction
         };
         return gOppositeDir[dir];
     }
@@ skipping 44 matching lines @@
      *  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);
         return computedDir == dir;
     }
 
-    /** Returns true if the path specifies a rectangle. If so, and if isClosed is
-        not null, set isClosed to true if the path is closed. Also, if returning true
-        and direction is not null, return the rect direction. If the path does not
-        specify a rectangle, return false and ignore isClosed and direction.
-
-        @param isClosed If not null, set to true if the path is closed
-        @param direction If not null, set to the rectangle's direction
-        @return true if the path specifies a rectangle
-    */
-    bool isRect(bool* isClosed, Direction* direction) const;
-
-    /** Returns true if the path specifies a pair of nested rectangles. If so, and if
-        rect is not null, set rect[0] to the outer rectangle and rect[1] to the inner
-        rectangle. If so, and dirs is not null, set dirs[0] to the direction of
-        the outer rectangle and dirs[1] to the direction of the inner rectangle. If
-        the path does not specify a pair of nested rectangles, return
-        false and ignore rect and dirs.
-
-        @param rect If not null, returns the path as a pair of nested rectangles
-        @param dirs If not null, returns the direction of the rects
-        @return true if the path describes a pair of nested rectangles
-    */
-    bool isNestedRects(SkRect rect[2], Direction dirs[2] = NULL) const;
-
     /**
      *  Add a closed rectangle contour to the path
      *  @param rect The rectangle to add as a closed contour to the path
      *  @param dir  The direction to wind the rectangle's contour. Cannot be
      *              kUnknown_Direction.
      */
     void    addRect(const SkRect& rect, Direction dir = kCW_Direction);
 
     /**
      *  Add a closed rectangle contour to the path
@@ skipping 407 matching lines @@
     bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts,
                        bool* isClosed, Direction* direction) const;
 
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test pathTo/reversePathTo
 };
 
 #endif