1 2 /* 3 * Copyright 2006 The Android Open Source Project 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10 #ifndef SkPathEffect_DEFINED 11 #define SkPathEffect_DEFINED 12 13 #include "SkFlattenable.h" 14 #include "SkPath.h" 15 #include "SkPoint.h" 16 #include "SkRect.h" 17 #include "SkStrokeRec.h" 18 #include "SkTDArray.h" 19 20 class SkPath; 21 22 /** \class SkPathEffect 23 24 SkPathEffect is the base class for objects in the SkPaint that affect 25 the geometry of a drawing primitive before it is transformed by the 26 canvas' matrix and drawn. 27 28 Dashing is implemented as a subclass of SkPathEffect. 29 */ 30 class SK_API SkPathEffect : public SkFlattenable { 31 public: 32 SK_DECLARE_INST_COUNT(SkPathEffect) 33 34 /** 35 * Given a src path (input) and a stroke-rec (input and output), apply 36 * this effect to the src path, returning the new path in dst, and return 37 * true. If this effect cannot be applied, return false and ignore dst 38 * and stroke-rec. 39 * 40 * The stroke-rec specifies the initial request for stroking (if any). 41 * The effect can treat this as input only, or it can choose to change 42 * the rec as well. For example, the effect can decide to change the 43 * stroke's width or join, or the effect can change the rec from stroke 44 * to fill (or fill to stroke) in addition to returning a new (dst) path. 45 * 46 * If this method returns true, the caller will apply (as needed) the 47 * resulting stroke-rec to dst and then draw. 48 */ 49 virtual bool filterPath(SkPath* dst, const SkPath& src, 50 SkStrokeRec*, const SkRect* cullR) const = 0; 51 52 /** 53 * Compute a conservative bounds for its effect, given the src bounds. 54 * The baseline implementation just assigns src to dst. 55 */ 56 virtual void computeFastBounds(SkRect* dst, const SkRect& src) const; 57 58 /** \class PointData 59 60 PointData aggregates all the information needed to draw the point 61 primitives returned by an 'asPoints' call. 62 */ 63 class PointData { 64 public: 65 PointData() 66 : fFlags(0) 67 , fPoints(NULL) 68 , fNumPoints(0) { 69 fSize.set(SK_Scalar1, SK_Scalar1); 70 // 'asPoints' needs to initialize/fill-in 'fClipRect' if it sets 71 // the kUseClip flag 72 }; 73 ~PointData() { 74 delete [] fPoints; 75 } 76 77 // TODO: consider using passed-in flags to limit the work asPoints does. 78 // For example, a kNoPath flag could indicate don't bother generating 79 // stamped solutions. 80 81 // Currently none of these flags are supported. 82 enum PointFlags { 83 kCircles_PointFlag = 0x01, // draw points as circles (instead of rects) 84 kUsePath_PointFlag = 0x02, // draw points as stamps of the returned path 85 kUseClip_PointFlag = 0x04, // apply 'fClipRect' before drawing the points 86 }; 87 88 uint32_t fFlags; // flags that impact the drawing of the points 89 SkPoint* fPoints; // the center point of each generated point 90 int fNumPoints; // number of points in fPoints 91 SkVector fSize; // the size to draw the points 92 SkRect fClipRect; // clip required to draw the points (if kUseClip is set) 93 SkPath fPath; // 'stamp' to be used at each point (if kUsePath is set) 94 95 SkPath fFirst; // If not empty, contains geometry for first point 96 SkPath fLast; // If not empty, contains geometry for last point 97 }; 98 99 /** 100 * Does applying this path effect to 'src' yield a set of points? If so, 101 * optionally return the points in 'results'. 102 */ 103 virtual bool asPoints(PointData* results, const SkPath& src, 104 const SkStrokeRec&, const SkMatrix&, 105 const SkRect* cullR) const; 106 107 /** 108 * If the PathEffect can be represented as a dash pattern, asADash will return kDash_DashType 109 * and None otherwise. If a non NULL info is passed in, the various DashInfo will be filled 110 * in if the PathEffect can be a dash pattern. If passed in info has an fCount equal or 111 * greater to that of the effect, it will memcpy the values of the dash intervals into the 112 * info. Thus the general approach will be call asADash once with default info to get DashType 113 * and fCount. If effect can be represented as a dash pattern, allocate space for the intervals 114 * in info, then call asADash again with the same info and the intervals will get copied in. 115 */ 116 117 enum DashType { 118 kNone_DashType, //!< ignores the info parameter 119 kDash_DashType, //!< fills in all of the info parameter 120 }; 121 122 struct DashInfo { 123 DashInfo() : fIntervals(NULL), fCount(0), fPhase(0) {} 124 125 SkScalar* fIntervals; //!< Length of on/off intervals for dashed lines 126 // Even values represent ons, and odds offs 127 int32_t fCount; //!< Number of intervals in the dash. Should be even number 128 SkScalar fPhase; //!< Offset into the dashed interval pattern 129 // mod the sum of all intervals 130 }; 131 132 virtual DashType asADash(DashInfo* info) const; 133 134 SK_DEFINE_FLATTENABLE_TYPE(SkPathEffect) 135 136 protected: 137 SkPathEffect() {} 138 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 139 SkPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {} 140 #endif 141 142 private: 143 // illegal 144 SkPathEffect(const SkPathEffect&); 145 SkPathEffect& operator=(const SkPathEffect&); 146 147 typedef SkFlattenable INHERITED; 148 }; 149 150 /** \class SkPairPathEffect 151 152 Common baseclass for Compose and Sum. This subclass manages two pathEffects, 153 including flattening them. It does nothing in filterPath, and is only useful 154 for managing the lifetimes of its two arguments. 155 */ 156 class SkPairPathEffect : public SkPathEffect { 157 public: 158 virtual ~SkPairPathEffect(); 159 160 protected: 161 SkPairPathEffect(SkPathEffect* pe0, SkPathEffect* pe1); 162 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 163 SkPairPathEffect(SkReadBuffer&); 164 #endif 165 166 virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE; 167 168 // these are visible to our subclasses 169 SkPathEffect* fPE0, *fPE1; 170 171 private: 172 typedef SkPathEffect INHERITED; 173 }; 174 175 /** \class SkComposePathEffect 176 177 This subclass of SkPathEffect composes its two arguments, to create 178 a compound pathEffect. 179 */ 180 class SkComposePathEffect : public SkPairPathEffect { 181 public: 182 /** Construct a pathEffect whose effect is to apply first the inner pathEffect 183 and the the outer pathEffect (e.g. outer(inner(path))) 184 The reference counts for outer and inner are both incremented in the constructor, 185 and decremented in the destructor. 186 */ 187 static SkComposePathEffect* Create(SkPathEffect* outer, SkPathEffect* inner) { 188 return SkNEW_ARGS(SkComposePathEffect, (outer, inner)); 189 } 190 191 virtual bool filterPath(SkPath* dst, const SkPath& src, 192 SkStrokeRec*, const SkRect*) const SK_OVERRIDE; 193 194 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposePathEffect) 195 196 protected: 197 SkComposePathEffect(SkPathEffect* outer, SkPathEffect* inner) 198 : INHERITED(outer, inner) {} 199 200 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 201 explicit SkComposePathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {} 202 #endif 203 204 private: 205 // illegal 206 SkComposePathEffect(const SkComposePathEffect&); 207 SkComposePathEffect& operator=(const SkComposePathEffect&); 208 209 typedef SkPairPathEffect INHERITED; 210 }; 211 212 /** \class SkSumPathEffect 213 214 This subclass of SkPathEffect applies two pathEffects, one after the other. 215 Its filterPath() returns true if either of the effects succeeded. 216 */ 217 class SkSumPathEffect : public SkPairPathEffect { 218 public: 219 /** Construct a pathEffect whose effect is to apply two effects, in sequence. 220 (e.g. first(path) + second(path)) 221 The reference counts for first and second are both incremented in the constructor, 222 and decremented in the destructor. 223 */ 224 static SkSumPathEffect* Create(SkPathEffect* first, SkPathEffect* second) { 225 return SkNEW_ARGS(SkSumPathEffect, (first, second)); 226 } 227 228 virtual bool filterPath(SkPath* dst, const SkPath& src, 229 SkStrokeRec*, const SkRect*) const SK_OVERRIDE; 230 231 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSumPathEffect) 232 233 protected: 234 SkSumPathEffect(SkPathEffect* first, SkPathEffect* second) 235 : INHERITED(first, second) {} 236 237 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 238 explicit SkSumPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {} 239 #endif 240 241 private: 242 // illegal 243 SkSumPathEffect(const SkSumPathEffect&); 244 SkSumPathEffect& operator=(const SkSumPathEffect&); 245 246 typedef SkPairPathEffect INHERITED; 247 }; 248 249 #endif 250
