Cleanup isRect variants

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 221 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;
 
-    /** 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 { return this->isRect(rect, NULL, NULL); }
-
     /** 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 17 matching lines @@
         @return the actual number of verbs in the path
     */
     int getVerbs(uint8_t verbs[], int max) const;
 
     //! Swap contents of this and other. Guaranteed not to throw
     void swap(SkPath& other);
 
     /** Returns the bounds of the path's points. If the path contains 0 or 1
         points, the bounds is set to (0,0,0,0), and isEmpty() will return true.
         Note: this bounds may be larger than the actual shape, since curves
-        do not extend as far as their control points.
+        do not extend as far as their control points. Additionally this bound
+        can contain trailing MoveTo points (cf. isRect).
     */
     const SkRect& getBounds() const {
         return fPathRef->getBounds();
     }
 
     /** Calling this will, if the internal cache of the bounds is out of date,
         update it so that subsequent calls to getBounds will be instantaneous.
         This also means that any copies or simple transformations of the path
         will inherit the cached bounds.
      */
@@ skipping 285 matching lines @@
     /** Returns kFill_PathAsRect or kStroke_PathAsRect if drawing the path (either filled or
         stroked) will be equivalent to filling/stroking the path's bounding rect. If
         either is true, and direction is not null, sets the direction of the contour. If the
         path is not drawn equivalent to a rect, returns kNone_PathAsRect and ignores direction.
 
         @param direction If not null, set to the contour's direction when it is drawn as a rect
         @return the path's PathAsRect type
      */
     PathAsRect asRect(Direction* direction = NULL) const;
 
-    /** 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 {
-        return this->isRect(NULL, isClosed, direction);
-    }
-
     /**
      *  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 rect If not null, set to the bounds of the rectangle.
+     *              Note : this bounds may be smaller than the path's bounds, since it is just
+     *              the bounds of the "drawable" parts of the path. e.g. a trailing MoveTo would
+     *              be ignored in this rect, but not by the path's bounds
      *  @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;
+    bool isRect(SkRect* rect, bool* isClosed = NULL, Direction* direction = NULL) 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
@@ skipping 445 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
 };
 
 #endif