Line data    Source code

       1             : /*
       2             :  * Copyright 2015 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #ifndef SkPathPriv_DEFINED
       9             : #define SkPathPriv_DEFINED
      10             : 
      11             : #include "SkPath.h"
      12             : 
      13             : class SkPathPriv {
      14             : public:
      15             :     enum FirstDirection {
      16             :         kCW_FirstDirection,         // == SkPath::kCW_Direction
      17             :         kCCW_FirstDirection,        // == SkPath::kCCW_Direction
      18             :         kUnknown_FirstDirection,
      19             :     };
      20             : 
      21             :     static FirstDirection AsFirstDirection(SkPath::Direction dir) {
      22             :         // since we agree numerically for the values in Direction, we can just cast.
      23             :         return (FirstDirection)dir;
      24             :     }
      25             : 
      26             :     /**
      27             :      *  Return the opposite of the specified direction. kUnknown is its own
      28             :      *  opposite.
      29             :      */
      30           0 :     static FirstDirection OppositeFirstDirection(FirstDirection dir) {
      31             :         static const FirstDirection gOppositeDir[] = {
      32             :             kCCW_FirstDirection, kCW_FirstDirection, kUnknown_FirstDirection,
      33             :         };
      34           0 :         return gOppositeDir[dir];
      35             :     }
      36             : 
      37             :     /**
      38             :      *  Tries to quickly compute the direction of the first non-degenerate
      39             :      *  contour. If it can be computed, return true and set dir to that
      40             :      *  direction. If it cannot be (quickly) determined, return false and ignore
      41             :      *  the dir parameter. If the direction was determined, it is cached to make
      42             :      *  subsequent calls return quickly.
      43             :      */
      44             :     static bool CheapComputeFirstDirection(const SkPath&, FirstDirection* dir);
      45             : 
      46             :     /**
      47             :      *  Returns true if the path's direction can be computed via
      48             :      *  cheapComputDirection() and if that computed direction matches the
      49             :      *  specified direction. If dir is kUnknown, returns true if the direction
      50             :      *  cannot be computed.
      51             :      */
      52           0 :     static bool CheapIsFirstDirection(const SkPath& path, FirstDirection dir) {
      53           0 :         FirstDirection computedDir = kUnknown_FirstDirection;
      54           0 :         (void)CheapComputeFirstDirection(path, &computedDir);
      55           0 :         return computedDir == dir;
      56             :     }
      57             : 
      58           0 :     static bool IsClosedSingleContour(const SkPath& path) {
      59           0 :         int verbCount = path.countVerbs();
      60           0 :         if (verbCount == 0)
      61           0 :             return false;
      62           0 :         int moveCount = 0;
      63           0 :         auto verbs = path.fPathRef->verbs();
      64           0 :         for (int i = 0; i < verbCount; i++) {
      65           0 :             switch (verbs[~i]) { // verbs are stored backwards; we use [~i] to get the i'th verb
      66             :                 case SkPath::Verb::kMove_Verb:
      67           0 :                     moveCount += 1;
      68           0 :                     if (moveCount > 1) {
      69           0 :                         return false;
      70             :                     }
      71           0 :                     break;
      72             :                 case SkPath::Verb::kClose_Verb:
      73           0 :                     if (i == verbCount - 1) {
      74           0 :                         return true;
      75             :                     }
      76           0 :                     return false;
      77           0 :                 default: break;
      78             :             }
      79             :         }
      80           0 :         return false;
      81             :     }
      82             : 
      83             :     static void AddGenIDChangeListener(const SkPath& path, SkPathRef::GenIDChangeListener* listener) {
      84             :         path.fPathRef->addGenIDChangeListener(listener);
      85             :     }
      86             : 
      87             :     /**
      88             :      * This returns true for a rect that begins and ends at the same corner and has either a move
      89             :      * followed by four lines or a move followed by 3 lines and a close. None of the parameters are
      90             :      * optional. This does not permit degenerate line or point rectangles.
      91             :      */
      92             :     static bool IsSimpleClosedRect(const SkPath& path, SkRect* rect, SkPath::Direction* direction,
      93             :                                    unsigned* start);
      94             : 
      95             :     /**
      96             :      * Creates a path from arc params using the semantics of SkCanvas::drawArc. This function
      97             :      * assumes empty ovals and zero sweeps have already been filtered out.
      98             :      */
      99             :     static void CreateDrawArcPath(SkPath* path, const SkRect& oval, SkScalar startAngle,
     100             :                                   SkScalar sweepAngle, bool useCenter, bool isFillNoPathEffect);
     101             : 
     102             :     /**
     103             :      * Returns a pointer to the verb data. Note that the verbs are stored backwards in memory and
     104             :      * thus the returned pointer is the last verb.
     105             :      */
     106           0 :     static const uint8_t* VerbData(const SkPath& path) {
     107           0 :         return path.fPathRef->verbsMemBegin();
     108             :     }
     109             : 
     110             :     /** Returns a raw pointer to the path points */
     111           0 :     static const SkPoint* PointData(const SkPath& path) {
     112           0 :         return path.fPathRef->points();
     113             :     }
     114             : 
     115             :     /** Returns the number of conic weights in the path */
     116           0 :     static int ConicWeightCnt(const SkPath& path) {
     117           0 :         return path.fPathRef->countWeights();
     118             :     }
     119             : 
     120             :     /** Returns a raw pointer to the path conic weights. */
     121           0 :     static const SkScalar* ConicWeightData(const SkPath& path) {
     122           0 :         return path.fPathRef->conicWeights();
     123             :     }
     124             : };
     125             : 
     126             : #endif