1 /* 2 * Copyright 2006 The Android Open Source Project 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 SkCanvas_DEFINED 9 #define SkCanvas_DEFINED 10 11 #include "SkTypes.h" 12 #include "SkBlendMode.h" 13 #include "SkBitmap.h" 14 #include "SkClipOp.h" 15 #include "SkDeque.h" 16 #include "SkImage.h" 17 #include "SkPaint.h" 18 #include "SkRefCnt.h" 19 #include "SkRegion.h" 20 #include "SkSurfaceProps.h" 21 #include "SkXfermode.h" 22 #include "SkLights.h" 23 #include "../private/SkShadowParams.h" 24 25 class GrContext; 26 class GrDrawContext; 27 class SkBaseDevice; 28 class SkCanvasClipVisitor; 29 class SkClipStack; 30 class SkData; 31 class SkDraw; 32 class SkDrawable; 33 class SkDrawFilter; 34 class SkImageFilter; 35 class SkMetaData; 36 class SkPath; 37 class SkPicture; 38 class SkPixmap; 39 class SkRasterClip; 40 class SkRRect; 41 struct SkRSXform; 42 class SkSurface; 43 class SkSurface_Base; 44 class SkTextBlob; 45 46 //#define SK_SUPPORT_LEGACY_CLIP_REGIONOPS 47 48 /** \class SkCanvas 49 50 A Canvas encapsulates all of the state about drawing into a device (bitmap). 51 This includes a reference to the device itself, and a stack of matrix/clip 52 values. For any given draw call (e.g. drawRect), the geometry of the object 53 being drawn is transformed by the concatenation of all the matrices in the 54 stack. The transformed geometry is clipped by the intersection of all of 55 the clips in the stack. 56 57 While the Canvas holds the state of the drawing device, the state (style) 58 of the object being drawn is held by the Paint, which is provided as a 59 parameter to each of the draw() methods. The Paint holds attributes such as 60 color, typeface, textSize, strokeWidth, shader (e.g. gradients, patterns), 61 etc. 62 */ 63 class SK_API SkCanvas : public SkRefCnt { 64 enum PrivateSaveLayerFlags { 65 kDontClipToLayer_PrivateSaveLayerFlag = 1U << 31, 66 }; 67 68 public: 69 #ifdef SK_SUPPORT_LEGACY_CLIP_REGIONOPS 70 typedef SkRegion::Op ClipOp; 71 72 static const ClipOp kDifference_Op = SkRegion::kDifference_Op; 73 static const ClipOp kIntersect_Op = SkRegion::kIntersect_Op; 74 static const ClipOp kUnion_Op = SkRegion::kUnion_Op; 75 static const ClipOp kXOR_Op = SkRegion::kXOR_Op; 76 static const ClipOp kReverseDifference_Op = SkRegion::kReverseDifference_Op; 77 static const ClipOp kReplace_Op = SkRegion::kReplace_Op; 78 #else 79 typedef SkClipOp ClipOp; 80 81 static const ClipOp kDifference_Op = kDifference_SkClipOp; 82 static const ClipOp kIntersect_Op = kIntersect_SkClipOp; 83 static const ClipOp kUnion_Op = kUnion_SkClipOp; 84 static const ClipOp kXOR_Op = kXOR_SkClipOp; 85 static const ClipOp kReverseDifference_Op = kReverseDifference_SkClipOp; 86 static const ClipOp kReplace_Op = kReplace_SkClipOp; 87 #endif 88 /** 89 * Attempt to allocate raster canvas, matching the ImageInfo, that will draw directly into the 90 * specified pixels. To access the pixels after drawing to them, the caller should call 91 * flush() or call peekPixels(...). 92 * 93 * On failure, return NULL. This can fail for several reasons: 94 * 1. invalid ImageInfo (e.g. negative dimensions) 95 * 2. unsupported ImageInfo for a canvas 96 * - kUnknown_SkColorType, kIndex_8_SkColorType 97 * - kUnknown_SkAlphaType 98 * - this list is not complete, so others may also be unsupported 99 * 100 * Note: it is valid to request a supported ImageInfo, but with zero 101 * dimensions. 102 */ 103 static SkCanvas* NewRasterDirect(const SkImageInfo&, void*, size_t); 104 NewRasterDirectN32(int width,int height,SkPMColor * pixels,size_t rowBytes)105 static SkCanvas* NewRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes) { 106 return NewRasterDirect(SkImageInfo::MakeN32Premul(width, height), pixels, rowBytes); 107 } 108 109 /** 110 * Creates an empty canvas with no backing device/pixels, and zero 111 * dimensions. 112 */ 113 SkCanvas(); 114 115 /** 116 * Creates a canvas of the specified dimensions, but explicitly not backed 117 * by any device/pixels. Typically this use used by subclasses who handle 118 * the draw calls in some other way. 119 */ 120 SkCanvas(int width, int height, const SkSurfaceProps* = NULL); 121 122 /** Construct a canvas with the specified device to draw into. 123 124 @param device Specifies a device for the canvas to draw into. 125 */ 126 explicit SkCanvas(SkBaseDevice* device); 127 128 /** Construct a canvas with the specified bitmap to draw into. 129 @param bitmap Specifies a bitmap for the canvas to draw into. Its 130 structure are copied to the canvas. 131 */ 132 explicit SkCanvas(const SkBitmap& bitmap); 133 134 /** Construct a canvas with the specified bitmap to draw into. 135 @param bitmap Specifies a bitmap for the canvas to draw into. Its 136 structure are copied to the canvas. 137 @param props New canvas surface properties. 138 */ 139 SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props); 140 141 virtual ~SkCanvas(); 142 143 SkMetaData& getMetaData(); 144 145 /** 146 * Return ImageInfo for this canvas. If the canvas is not backed by pixels 147 * (cpu or gpu), then the info's ColorType will be kUnknown_SkColorType. 148 */ 149 SkImageInfo imageInfo() const; 150 151 /** 152 * If the canvas is backed by pixels (cpu or gpu), this writes a copy of the SurfaceProps 153 * for the canvas to the location supplied by the caller, and returns true. Otherwise, 154 * return false and leave the supplied props unchanged. 155 */ 156 bool getProps(SkSurfaceProps*) const; 157 158 /////////////////////////////////////////////////////////////////////////// 159 160 /** 161 * Trigger the immediate execution of all pending draw operations. For the GPU 162 * backend this will resolve all rendering to the GPU surface backing the 163 * SkSurface that owns this canvas. 164 */ 165 void flush(); 166 167 /** 168 * Gets the size of the base or root layer in global canvas coordinates. The 169 * origin of the base layer is always (0,0). The current drawable area may be 170 * smaller (due to clipping or saveLayer). 171 */ 172 virtual SkISize getBaseLayerSize() const; 173 174 /** 175 * DEPRECATED: call getBaseLayerSize 176 */ getDeviceSize()177 SkISize getDeviceSize() const { return this->getBaseLayerSize(); } 178 179 /** 180 * DEPRECATED. 181 * Return the canvas' device object, which may be null. The device holds 182 * the bitmap of the pixels that the canvas draws into. The reference count 183 * of the returned device is not changed by this call. 184 */ 185 #ifndef SK_SUPPORT_LEGACY_GETDEVICE 186 protected: // Can we make this private? 187 #endif 188 SkBaseDevice* getDevice() const; 189 public: getDevice_just_for_deprecated_compatibility_testing()190 SkBaseDevice* getDevice_just_for_deprecated_compatibility_testing() const { 191 return this->getDevice(); 192 } 193 194 /** 195 * saveLayer() can create another device (which is later drawn onto 196 * the previous device). getTopDevice() returns the top-most device current 197 * installed. Note that this can change on other calls like save/restore, 198 * so do not access this device after subsequent canvas calls. 199 * The reference count of the device is not changed. 200 * 201 * @param updateMatrixClip If this is true, then before the device is 202 * returned, we ensure that its has been notified about the current 203 * matrix and clip. Note: this happens automatically when the device 204 * is drawn to, but is optional here, as there is a small perf hit 205 * sometimes. 206 */ 207 #ifndef SK_SUPPORT_LEGACY_GETTOPDEVICE 208 private: 209 #endif 210 SkBaseDevice* getTopDevice(bool updateMatrixClip = false) const; 211 public: 212 213 /** 214 * Create a new surface matching the specified info, one that attempts to 215 * be maximally compatible when used with this canvas. If there is no matching Surface type, 216 * NULL is returned. 217 * 218 * If surfaceprops is specified, those are passed to the new surface, otherwise the new surface 219 * inherits the properties of the surface that owns this canvas. If this canvas has no parent 220 * surface, then the new surface is created with default properties. 221 */ 222 sk_sp<SkSurface> makeSurface(const SkImageInfo&, const SkSurfaceProps* = nullptr); 223 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API 224 SkSurface* newSurface(const SkImageInfo& info, const SkSurfaceProps* props = NULL); 225 #endif 226 227 /** 228 * Return the GPU context of the device that is associated with the canvas. 229 * For a canvas with non-GPU device, NULL is returned. 230 */ 231 GrContext* getGrContext(); 232 233 /////////////////////////////////////////////////////////////////////////// 234 235 /** 236 * If the canvas has writable pixels in its top layer (and is not recording to a picture 237 * or other non-raster target) and has direct access to its pixels (i.e. they are in 238 * local RAM) return the address of those pixels, and if not null, 239 * return the ImageInfo, rowBytes and origin. The returned address is only valid 240 * while the canvas object is in scope and unchanged. Any API calls made on 241 * canvas (or its parent surface if any) will invalidate the 242 * returned address (and associated information). 243 * 244 * On failure, returns NULL and the info, rowBytes, and origin parameters are ignored. 245 */ 246 void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin = NULL); 247 248 /** 249 * If the canvas has readable pixels in its base layer (and is not recording to a picture 250 * or other non-raster target) and has direct access to its pixels (i.e. they are in 251 * local RAM) return true, and if not null, return in the pixmap parameter information about 252 * the pixels. The pixmap's pixel address is only valid 253 * while the canvas object is in scope and unchanged. Any API calls made on 254 * canvas (or its parent surface if any) will invalidate the pixel address 255 * (and associated information). 256 * 257 * On failure, returns false and the pixmap parameter will be ignored. 258 */ 259 bool peekPixels(SkPixmap*); 260 261 #ifdef SK_SUPPORT_LEGACY_PEEKPIXELS_PARMS 262 const void* peekPixels(SkImageInfo* info, size_t* rowBytes); 263 #endif 264 265 /** 266 * Copy the pixels from the base-layer into the specified buffer (pixels + rowBytes), 267 * converting them into the requested format (SkImageInfo). The base-layer pixels are read 268 * starting at the specified (srcX,srcY) location in the coordinate system of the base-layer. 269 * 270 * The specified ImageInfo and (srcX,srcY) offset specifies a source rectangle 271 * 272 * srcR.setXYWH(srcX, srcY, dstInfo.width(), dstInfo.height()); 273 * 274 * srcR is intersected with the bounds of the base-layer. If this intersection is not empty, 275 * then we have two sets of pixels (of equal size). Replace the dst pixels with the 276 * corresponding src pixels, performing any colortype/alphatype transformations needed 277 * (in the case where the src and dst have different colortypes or alphatypes). 278 * 279 * This call can fail, returning false, for several reasons: 280 * - If srcR does not intersect the base-layer bounds. 281 * - If the requested colortype/alphatype cannot be converted from the base-layer's types. 282 * - If this canvas is not backed by pixels (e.g. picture or PDF) 283 */ 284 bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, 285 int srcX, int srcY); 286 287 /** 288 * Helper for calling readPixels(info, ...). This call will check if bitmap has been allocated. 289 * If not, it will attempt to call allocPixels(). If this fails, it will return false. If not, 290 * it calls through to readPixels(info, ...) and returns its result. 291 */ 292 bool readPixels(SkBitmap* bitmap, int srcX, int srcY); 293 294 /** 295 * Helper for allocating pixels and then calling readPixels(info, ...). The bitmap is resized 296 * to the intersection of srcRect and the base-layer bounds. On success, pixels will be 297 * allocated in bitmap and true returned. On failure, false is returned and bitmap will be 298 * set to empty. 299 */ 300 bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap); 301 302 /** 303 * This method affects the pixels in the base-layer, and operates in pixel coordinates, 304 * ignoring the matrix and clip. 305 * 306 * The specified ImageInfo and (x,y) offset specifies a rectangle: target. 307 * 308 * target.setXYWH(x, y, info.width(), info.height()); 309 * 310 * Target is intersected with the bounds of the base-layer. If this intersection is not empty, 311 * then we have two sets of pixels (of equal size), the "src" specified by info+pixels+rowBytes 312 * and the "dst" by the canvas' backend. Replace the dst pixels with the corresponding src 313 * pixels, performing any colortype/alphatype transformations needed (in the case where the 314 * src and dst have different colortypes or alphatypes). 315 * 316 * This call can fail, returning false, for several reasons: 317 * - If the src colortype/alphatype cannot be converted to the canvas' types 318 * - If this canvas is not backed by pixels (e.g. picture or PDF) 319 */ 320 bool writePixels(const SkImageInfo&, const void* pixels, size_t rowBytes, int x, int y); 321 322 /** 323 * Helper for calling writePixels(info, ...) by passing its pixels and rowbytes. If the bitmap 324 * is just wrapping a texture, returns false and does nothing. 325 */ 326 bool writePixels(const SkBitmap& bitmap, int x, int y); 327 328 /////////////////////////////////////////////////////////////////////////// 329 330 /** This call saves the current matrix, clip, and drawFilter, and pushes a 331 copy onto a private stack. Subsequent calls to translate, scale, 332 rotate, skew, concat or clipRect, clipPath, and setDrawFilter all 333 operate on this copy. 334 When the balancing call to restore() is made, the previous matrix, clip, 335 and drawFilter are restored. 336 337 @return The value to pass to restoreToCount() to balance this save() 338 */ 339 int save(); 340 341 /** This behaves the same as save(), but in addition it allocates an 342 offscreen bitmap. All drawing calls are directed there, and only when 343 the balancing call to restore() is made is that offscreen transfered to 344 the canvas (or the previous layer). 345 @param bounds (may be null) This rect, if non-null, is used as a hint to 346 limit the size of the offscreen, and thus drawing may be 347 clipped to it, though that clipping is not guaranteed to 348 happen. If exact clipping is desired, use clipRect(). 349 @param paint (may be null) This is copied, and is applied to the 350 offscreen when restore() is called 351 @return The value to pass to restoreToCount() to balance this save() 352 */ 353 int saveLayer(const SkRect* bounds, const SkPaint* paint); saveLayer(const SkRect & bounds,const SkPaint * paint)354 int saveLayer(const SkRect& bounds, const SkPaint* paint) { 355 return this->saveLayer(&bounds, paint); 356 } 357 358 /** 359 * Temporary name. 360 * Will allow any requests for LCD text to be respected, so the caller must be careful to 361 * only draw on top of opaque sections of the layer to get good results. 362 */ 363 int saveLayerPreserveLCDTextRequests(const SkRect* bounds, const SkPaint* paint); 364 365 /** This behaves the same as save(), but in addition it allocates an 366 offscreen bitmap. All drawing calls are directed there, and only when 367 the balancing call to restore() is made is that offscreen transfered to 368 the canvas (or the previous layer). 369 @param bounds (may be null) This rect, if non-null, is used as a hint to 370 limit the size of the offscreen, and thus drawing may be 371 clipped to it, though that clipping is not guaranteed to 372 happen. If exact clipping is desired, use clipRect(). 373 @param alpha This is applied to the offscreen when restore() is called. 374 @return The value to pass to restoreToCount() to balance this save() 375 */ 376 int saveLayerAlpha(const SkRect* bounds, U8CPU alpha); 377 378 enum { 379 kIsOpaque_SaveLayerFlag = 1 << 0, 380 kPreserveLCDText_SaveLayerFlag = 1 << 1, 381 382 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG 383 kDontClipToLayer_Legacy_SaveLayerFlag = kDontClipToLayer_PrivateSaveLayerFlag, 384 #endif 385 }; 386 typedef uint32_t SaveLayerFlags; 387 388 struct SaveLayerRec { SaveLayerRecSaveLayerRec389 SaveLayerRec() 390 : fBounds(nullptr), fPaint(nullptr), fBackdrop(nullptr), fSaveLayerFlags(0) 391 {} 392 SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0) fBoundsSaveLayerRec393 : fBounds(bounds) 394 , fPaint(paint) 395 , fBackdrop(nullptr) 396 , fSaveLayerFlags(saveLayerFlags) 397 {} SaveLayerRecSaveLayerRec398 SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, 399 SaveLayerFlags saveLayerFlags) 400 : fBounds(bounds) 401 , fPaint(paint) 402 , fBackdrop(backdrop) 403 , fSaveLayerFlags(saveLayerFlags) 404 {} 405 406 const SkRect* fBounds; // optional 407 const SkPaint* fPaint; // optional 408 const SkImageFilter* fBackdrop; // optional 409 SaveLayerFlags fSaveLayerFlags; 410 }; 411 412 int saveLayer(const SaveLayerRec&); 413 414 /** This call balances a previous call to save(), and is used to remove all 415 modifications to the matrix/clip/drawFilter state since the last save 416 call. 417 It is an error to call restore() more times than save() was called. 418 */ 419 void restore(); 420 421 /** Returns the number of matrix/clip states on the SkCanvas' private stack. 422 This will equal # save() calls - # restore() calls + 1. The save count on 423 a new canvas is 1. 424 */ 425 int getSaveCount() const; 426 427 /** Efficient way to pop any calls to save() that happened after the save 428 count reached saveCount. It is an error for saveCount to be greater than 429 getSaveCount(). To pop all the way back to the initial matrix/clip context 430 pass saveCount == 1. 431 @param saveCount The number of save() levels to restore from 432 */ 433 void restoreToCount(int saveCount); 434 435 /** Preconcat the current matrix with the specified translation 436 @param dx The distance to translate in X 437 @param dy The distance to translate in Y 438 */ 439 void translate(SkScalar dx, SkScalar dy); 440 441 /** Preconcat the current matrix with the specified scale. 442 @param sx The amount to scale in X 443 @param sy The amount to scale in Y 444 */ 445 void scale(SkScalar sx, SkScalar sy); 446 447 /** Preconcat the current matrix with the specified rotation about the origin. 448 @param degrees The amount to rotate, in degrees 449 */ 450 void rotate(SkScalar degrees); 451 452 /** Preconcat the current matrix with the specified rotation about a given point. 453 @param degrees The amount to rotate, in degrees 454 @param px The x coordinate of the point to rotate about. 455 @param py The y coordinate of the point to rotate about. 456 */ 457 void rotate(SkScalar degrees, SkScalar px, SkScalar py); 458 459 /** Preconcat the current matrix with the specified skew. 460 @param sx The amount to skew in X 461 @param sy The amount to skew in Y 462 */ 463 void skew(SkScalar sx, SkScalar sy); 464 465 /** Preconcat the current matrix with the specified matrix. 466 @param matrix The matrix to preconcatenate with the current matrix 467 */ 468 void concat(const SkMatrix& matrix); 469 470 /** Replace the current matrix with a copy of the specified matrix. 471 @param matrix The matrix that will be copied into the current matrix. 472 */ 473 void setMatrix(const SkMatrix& matrix); 474 475 /** Helper for setMatrix(identity). Sets the current matrix to identity. 476 */ 477 void resetMatrix(); 478 479 #ifdef SK_EXPERIMENTAL_SHADOWING 480 /** Add the specified translation to the current draw depth of the canvas. 481 @param z The distance to translate in Z. 482 Negative into screen, positive out of screen. 483 Without translation, the draw depth defaults to 0. 484 */ 485 void translateZ(SkScalar z); 486 487 /** Set the current set of lights in the canvas. 488 @param lights The lights that we want the canvas to have. 489 */ 490 void setLights(sk_sp<SkLights> lights); 491 492 /** Returns the current set of lights the canvas uses 493 */ 494 sk_sp<SkLights> getLights() const; 495 #endif 496 497 /** 498 * Modify the current clip with the specified rectangle. 499 * @param rect The rect to combine with the current clip 500 * @param op The region op to apply to the current clip 501 * @param doAntiAlias true if the clip should be antialiased 502 */ 503 void clipRect(const SkRect& rect, ClipOp, bool doAntiAlias); clipRect(const SkRect & rect,ClipOp op)504 void clipRect(const SkRect& rect, ClipOp op) { 505 this->clipRect(rect, op, false); 506 } 507 void clipRect(const SkRect& rect, bool doAntiAlias = false) { 508 this->clipRect(rect, kIntersect_Op, doAntiAlias); 509 } 510 511 /** 512 * Modify the current clip with the specified SkRRect. 513 * @param rrect The rrect to combine with the current clip 514 * @param op The region op to apply to the current clip 515 * @param doAntiAlias true if the clip should be antialiased 516 */ 517 void clipRRect(const SkRRect& rrect, ClipOp op, bool doAntiAlias); clipRRect(const SkRRect & rrect,ClipOp op)518 void clipRRect(const SkRRect& rrect, ClipOp op) { 519 this->clipRRect(rrect, op, false); 520 } 521 void clipRRect(const SkRRect& rrect, bool doAntiAlias = false) { 522 this->clipRRect(rrect, kIntersect_Op, doAntiAlias); 523 } 524 525 /** 526 * Modify the current clip with the specified path. 527 * @param path The path to combine with the current clip 528 * @param op The region op to apply to the current clip 529 * @param doAntiAlias true if the clip should be antialiased 530 */ 531 void clipPath(const SkPath& path, ClipOp op, bool doAntiAlias); clipPath(const SkPath & path,ClipOp op)532 void clipPath(const SkPath& path, ClipOp op) { 533 this->clipPath(path, op, false); 534 } 535 void clipPath(const SkPath& path, bool doAntiAlias = false) { 536 this->clipPath(path, kIntersect_Op, doAntiAlias); 537 } 538 539 /** EXPERIMENTAL -- only used for testing 540 Set to simplify clip stack using path ops. 541 */ setAllowSimplifyClip(bool allow)542 void setAllowSimplifyClip(bool allow) { 543 fAllowSimplifyClip = allow; 544 } 545 546 /** Modify the current clip with the specified region. Note that unlike 547 clipRect() and clipPath() which transform their arguments by the current 548 matrix, clipRegion() assumes its argument is already in device 549 coordinates, and so no transformation is performed. 550 @param deviceRgn The region to apply to the current clip 551 @param op The region op to apply to the current clip 552 */ 553 void clipRegion(const SkRegion& deviceRgn, ClipOp op = kIntersect_Op); 554 555 /** Return true if the specified rectangle, after being transformed by the 556 current matrix, would lie completely outside of the current clip. Call 557 this to check if an area you intend to draw into is clipped out (and 558 therefore you can skip making the draw calls). 559 @param rect the rect to compare with the current clip 560 @return true if the rect (transformed by the canvas' matrix) does not 561 intersect with the canvas' clip 562 */ 563 bool quickReject(const SkRect& rect) const; 564 565 /** Return true if the specified path, after being transformed by the 566 current matrix, would lie completely outside of the current clip. Call 567 this to check if an area you intend to draw into is clipped out (and 568 therefore you can skip making the draw calls). Note, for speed it may 569 return false even if the path itself might not intersect the clip 570 (i.e. the bounds of the path intersects, but the path does not). 571 @param path The path to compare with the current clip 572 @return true if the path (transformed by the canvas' matrix) does not 573 intersect with the canvas' clip 574 */ 575 bool quickReject(const SkPath& path) const; 576 577 /** Return the bounds of the current clip (in local coordinates) in the 578 bounds parameter, and return true if it is non-empty. This can be useful 579 in a way similar to quickReject, in that it tells you that drawing 580 outside of these bounds will be clipped out. 581 */ 582 virtual bool getClipBounds(SkRect* bounds) const; 583 584 /** Return the bounds of the current clip, in device coordinates; returns 585 true if non-empty. Maybe faster than getting the clip explicitly and 586 then taking its bounds. 587 */ 588 virtual bool getClipDeviceBounds(SkIRect* bounds) const; 589 590 591 /** Fill the entire canvas' bitmap (restricted to the current clip) with the 592 specified ARGB color, using the specified mode. 593 @param a the alpha component (0..255) of the color to fill the canvas 594 @param r the red component (0..255) of the color to fill the canvas 595 @param g the green component (0..255) of the color to fill the canvas 596 @param b the blue component (0..255) of the color to fill the canvas 597 @param mode the mode to apply the color in (defaults to SrcOver) 598 */ 599 void drawARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b, SkBlendMode mode = SkBlendMode::kSrcOver); 600 #ifdef SK_SUPPORT_LEGACY_XFERMODE_OBJECT drawARGB(U8CPU a,U8CPU r,U8CPU g,U8CPU b,SkXfermode::Mode mode)601 void drawARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b, SkXfermode::Mode mode) { 602 this->drawARGB(a, r, g, b, (SkBlendMode)mode); 603 } 604 #endif 605 606 /** Fill the entire canvas' bitmap (restricted to the current clip) with the 607 specified color and mode. 608 @param color the color to draw with 609 @param mode the mode to apply the color in (defaults to SrcOver) 610 */ 611 void drawColor(SkColor color, SkBlendMode mode = SkBlendMode::kSrcOver); 612 #ifdef SK_SUPPORT_LEGACY_XFERMODE_OBJECT drawColor(SkColor color,SkXfermode::Mode mode)613 void drawColor(SkColor color, SkXfermode::Mode mode) { 614 this->drawColor(color, (SkBlendMode)mode); 615 } 616 #endif 617 618 /** 619 * Helper method for drawing a color in SRC mode, completely replacing all the pixels 620 * in the current clip with this color. 621 */ clear(SkColor color)622 void clear(SkColor color) { 623 this->drawColor(color, SkBlendMode::kSrc); 624 } 625 626 /** 627 * This makes the contents of the canvas undefined. Subsequent calls that 628 * require reading the canvas contents will produce undefined results. Examples 629 * include blending and readPixels. The actual implementation is backend- 630 * dependent and one legal implementation is to do nothing. This method 631 * ignores the current clip. 632 * 633 * This function should only be called if the caller intends to subsequently 634 * draw to the canvas. The canvas may do real work at discard() time in order 635 * to optimize performance on subsequent draws. Thus, if you call this and then 636 * never draw to the canvas subsequently you may pay a perfomance penalty. 637 */ discard()638 void discard() { this->onDiscard(); } 639 640 /** 641 * Fill the entire canvas (restricted to the current clip) with the 642 * specified paint. 643 * @param paint The paint used to fill the canvas 644 */ 645 void drawPaint(const SkPaint& paint); 646 647 enum PointMode { 648 /** drawPoints draws each point separately */ 649 kPoints_PointMode, 650 /** drawPoints draws each pair of points as a line segment */ 651 kLines_PointMode, 652 /** drawPoints draws the array of points as a polygon */ 653 kPolygon_PointMode 654 }; 655 656 /** Draw a series of points, interpreted based on the PointMode mode. For 657 all modes, the count parameter is interpreted as the total number of 658 points. For kLine mode, count/2 line segments are drawn. 659 For kPoint mode, each point is drawn centered at its coordinate, and its 660 size is specified by the paint's stroke-width. It draws as a square, 661 unless the paint's cap-type is round, in which the points are drawn as 662 circles. 663 For kLine mode, each pair of points is drawn as a line segment, 664 respecting the paint's settings for cap/join/width. 665 For kPolygon mode, the entire array is drawn as a series of connected 666 line segments. 667 Note that, while similar, kLine and kPolygon modes draw slightly 668 differently than the equivalent path built with a series of moveto, 669 lineto calls, in that the path will draw all of its contours at once, 670 with no interactions if contours intersect each other (think XOR 671 xfermode). drawPoints always draws each element one at a time. 672 @param mode PointMode specifying how to draw the array of points. 673 @param count The number of points in the array 674 @param pts Array of points to draw 675 @param paint The paint used to draw the points 676 */ 677 void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint); 678 679 /** Helper method for drawing a single point. See drawPoints() for a more 680 details. 681 */ 682 void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint); 683 684 /** Draws a single pixel in the specified color. 685 @param x The X coordinate of which pixel to draw 686 @param y The Y coordiante of which pixel to draw 687 @param color The color to draw 688 */ 689 void drawPoint(SkScalar x, SkScalar y, SkColor color); 690 691 /** Draw a line segment with the specified start and stop x,y coordinates, 692 using the specified paint. NOTE: since a line is always "framed", the 693 paint's Style is ignored. 694 @param x0 The x-coordinate of the start point of the line 695 @param y0 The y-coordinate of the start point of the line 696 @param x1 The x-coordinate of the end point of the line 697 @param y1 The y-coordinate of the end point of the line 698 @param paint The paint used to draw the line 699 */ 700 void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, 701 const SkPaint& paint); 702 703 /** Draw the specified rectangle using the specified paint. The rectangle 704 will be filled or stroked based on the Style in the paint. 705 @param rect The rect to be drawn 706 @param paint The paint used to draw the rect 707 */ 708 void drawRect(const SkRect& rect, const SkPaint& paint); 709 710 /** Draw the specified rectangle using the specified paint. The rectangle 711 will be filled or framed based on the Style in the paint. 712 @param rect The rect to be drawn 713 @param paint The paint used to draw the rect 714 */ drawIRect(const SkIRect & rect,const SkPaint & paint)715 void drawIRect(const SkIRect& rect, const SkPaint& paint) { 716 SkRect r; 717 r.set(rect); // promotes the ints to scalars 718 this->drawRect(r, paint); 719 } 720 721 /** Draw the specified rectangle using the specified paint. The rectangle 722 will be filled or framed based on the Style in the paint. 723 @param left The left side of the rectangle to be drawn 724 @param top The top side of the rectangle to be drawn 725 @param right The right side of the rectangle to be drawn 726 @param bottom The bottom side of the rectangle to be drawn 727 @param paint The paint used to draw the rect 728 */ 729 void drawRectCoords(SkScalar left, SkScalar top, SkScalar right, 730 SkScalar bottom, const SkPaint& paint); 731 732 /** Draw the outline of the specified region using the specified paint. 733 @param region The region to be drawn 734 @param paint The paint used to draw the region 735 */ 736 void drawRegion(const SkRegion& region, const SkPaint& paint); 737 738 /** Draw the specified oval using the specified paint. The oval will be 739 filled or framed based on the Style in the paint. 740 @param oval The rectangle bounds of the oval to be drawn 741 @param paint The paint used to draw the oval 742 */ 743 void drawOval(const SkRect& oval, const SkPaint&); 744 745 /** 746 * Draw the specified RRect using the specified paint The rrect will be filled or stroked 747 * based on the Style in the paint. 748 * 749 * @param rrect The round-rect to draw 750 * @param paint The paint used to draw the round-rect 751 */ 752 void drawRRect(const SkRRect& rrect, const SkPaint& paint); 753 754 /** 755 * Draw the annulus formed by the outer and inner rrects. The results 756 * are undefined if the outer does not contain the inner. 757 */ 758 void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint&); 759 760 /** Draw the specified circle using the specified paint. If radius is <= 0, 761 then nothing will be drawn. The circle will be filled 762 or framed based on the Style in the paint. 763 @param cx The x-coordinate of the center of the cirle to be drawn 764 @param cy The y-coordinate of the center of the cirle to be drawn 765 @param radius The radius of the cirle to be drawn 766 @param paint The paint used to draw the circle 767 */ 768 void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, 769 const SkPaint& paint); 770 771 /** Draw the specified arc, which will be scaled to fit inside the 772 specified oval. Sweep angles are not treated as modulo 360 and thus can 773 exceed a full sweep of the oval. Note that this differs slightly from 774 SkPath::arcTo, which treats the sweep angle mod 360. If the oval is empty 775 or the sweep angle is zero nothing is drawn. If useCenter is true the oval 776 center is inserted into the implied path before the arc and the path is 777 closed back to the, center forming a wedge. Otherwise, the implied path 778 contains just the arc and is not closed. 779 @param oval The bounds of oval used to define the shape of the arc. 780 @param startAngle Starting angle (in degrees) where the arc begins 781 @param sweepAngle Sweep angle (in degrees) measured clockwise. 782 @param useCenter true means include the center of the oval. 783 @param paint The paint used to draw the arc 784 */ 785 void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, 786 bool useCenter, const SkPaint& paint); 787 788 /** Draw the specified round-rect using the specified paint. The round-rect 789 will be filled or framed based on the Style in the paint. 790 @param rect The rectangular bounds of the roundRect to be drawn 791 @param rx The x-radius of the oval used to round the corners 792 @param ry The y-radius of the oval used to round the corners 793 @param paint The paint used to draw the roundRect 794 */ 795 void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, 796 const SkPaint& paint); 797 798 /** Draw the specified path using the specified paint. The path will be 799 filled or framed based on the Style in the paint. 800 @param path The path to be drawn 801 @param paint The paint used to draw the path 802 */ 803 void drawPath(const SkPath& path, const SkPaint& paint); 804 805 /** Draw the specified image, with its top/left corner at (x,y), using the 806 specified paint, transformed by the current matrix. 807 808 @param image The image to be drawn 809 @param left The position of the left side of the image being drawn 810 @param top The position of the top side of the image being drawn 811 @param paint The paint used to draw the image, or NULL 812 */ 813 void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = NULL); 814 void drawImage(const sk_sp<SkImage>& image, SkScalar left, SkScalar top, 815 const SkPaint* paint = NULL) { 816 this->drawImage(image.get(), left, top, paint); 817 } 818 819 /** 820 * Controls the behavior at the edge of the src-rect, when specified in drawImageRect, 821 * trading off speed for exactness. 822 * 823 * When filtering is enabled (in the Paint), skia may need to sample in a neighborhood around 824 * the pixels in the image. If there is a src-rect specified, it is intended to restrict the 825 * pixels that will be read. However, for performance reasons, some implementations may slow 826 * down if they cannot read 1-pixel past the src-rect boundary at times. 827 * 828 * This enum allows the caller to specify if such a 1-pixel "slop" will be visually acceptable. 829 * If it is, the caller should pass kFast, and it may result in a faster draw. If the src-rect 830 * must be strictly respected, the caller should pass kStrict. 831 */ 832 enum SrcRectConstraint { 833 /** 834 * If kStrict is specified, the implementation must respect the src-rect 835 * (if specified) strictly, and will never sample outside of those bounds during sampling 836 * even when filtering. This may be slower than kFast. 837 */ 838 kStrict_SrcRectConstraint, 839 840 /** 841 * If kFast is specified, the implementation may sample outside of the src-rect 842 * (if specified) by half the width of filter. This allows greater flexibility 843 * to the implementation and can make the draw much faster. 844 */ 845 kFast_SrcRectConstraint, 846 }; 847 848 /** Draw the specified image, scaling and translating so that it fills the specified 849 * dst rect. If the src rect is non-null, only that subset of the image is transformed 850 * and drawn. 851 * 852 * @param image The image to be drawn 853 * @param src Optional: specify the subset of the image to be drawn 854 * @param dst The destination rectangle where the scaled/translated 855 * image will be drawn 856 * @param paint The paint used to draw the image, or NULL 857 * @param constraint Control the tradeoff between speed and exactness w.r.t. the src-rect. 858 */ 859 void drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst, 860 const SkPaint* paint, 861 SrcRectConstraint constraint = kStrict_SrcRectConstraint); 862 // variant that takes src SkIRect 863 void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst, 864 const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint); 865 // variant that assumes src == image-bounds 866 void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint, 867 SrcRectConstraint = kStrict_SrcRectConstraint); 868 869 void drawImageRect(const sk_sp<SkImage>& image, const SkRect& src, const SkRect& dst, 870 const SkPaint* paint, 871 SrcRectConstraint constraint = kStrict_SrcRectConstraint) { 872 this->drawImageRect(image.get(), src, dst, paint, constraint); 873 } 874 void drawImageRect(const sk_sp<SkImage>& image, const SkIRect& isrc, const SkRect& dst, 875 const SkPaint* paint, SrcRectConstraint cons = kStrict_SrcRectConstraint) { 876 this->drawImageRect(image.get(), isrc, dst, paint, cons); 877 } 878 void drawImageRect(const sk_sp<SkImage>& image, const SkRect& dst, const SkPaint* paint, 879 SrcRectConstraint cons = kStrict_SrcRectConstraint) { 880 this->drawImageRect(image.get(), dst, paint, cons); 881 } 882 883 /** 884 * Draw the image stretched differentially to fit into dst. 885 * center is a rect within the image, and logically divides the image 886 * into 9 sections (3x3). For example, if the middle pixel of a [5x5] 887 * image is the "center", then the center-rect should be [2, 2, 3, 3]. 888 * 889 * If the dst is >= the image size, then... 890 * - The 4 corners are not stretched at all. 891 * - The sides are stretched in only one axis. 892 * - The center is stretched in both axes. 893 * Else, for each axis where dst < image, 894 * - The corners shrink proportionally 895 * - The sides (along the shrink axis) and center are not drawn 896 */ 897 void drawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst, 898 const SkPaint* paint = nullptr); 899 void drawImageNine(const sk_sp<SkImage>& image, const SkIRect& center, const SkRect& dst, 900 const SkPaint* paint = nullptr) { 901 this->drawImageNine(image.get(), center, dst, paint); 902 } 903 904 /** Draw the specified bitmap, with its top/left corner at (x,y), using the 905 specified paint, transformed by the current matrix. Note: if the paint 906 contains a maskfilter that generates a mask which extends beyond the 907 bitmap's original width/height, then the bitmap will be drawn as if it 908 were in a Shader with CLAMP mode. Thus the color outside of the original 909 width/height will be the edge color replicated. 910 911 If a shader is present on the paint it will be ignored, except in the 912 case where the bitmap is kAlpha_8_SkColorType. In that case, the color is 913 generated by the shader. 914 915 @param bitmap The bitmap to be drawn 916 @param left The position of the left side of the bitmap being drawn 917 @param top The position of the top side of the bitmap being drawn 918 @param paint The paint used to draw the bitmap, or NULL 919 */ 920 void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, 921 const SkPaint* paint = NULL); 922 923 /** Draw the specified bitmap, scaling and translating so that it fills the specified 924 * dst rect. If the src rect is non-null, only that subset of the bitmap is transformed 925 * and drawn. 926 * 927 * @param bitmap The bitmap to be drawn 928 * @param src Optional: specify the subset of the bitmap to be drawn 929 * @param dst The destination rectangle where the scaled/translated 930 * bitmap will be drawn 931 * @param paint The paint used to draw the bitmap, or NULL 932 * @param constraint Control the tradeoff between speed and exactness w.r.t. the src-rect. 933 */ 934 void drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst, 935 const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint); 936 // variant where src is SkIRect 937 void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst, 938 const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint); 939 void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint, 940 SrcRectConstraint = kStrict_SrcRectConstraint); 941 942 /** 943 * Draw the bitmap stretched or shrunk differentially to fit into dst. 944 * center is a rect within the bitmap, and logically divides the bitmap 945 * into 9 sections (3x3). For example, if the middle pixel of a [5x5] 946 * bitmap is the "center", then the center-rect should be [2, 2, 3, 3]. 947 * 948 * If the dst is >= the bitmap size, then... 949 * - The 4 corners are not stretched at all. 950 * - The sides are stretched in only one axis. 951 * - The center is stretched in both axes. 952 * Else, for each axis where dst < bitmap, 953 * - The corners shrink proportionally 954 * - The sides (along the shrink axis) and center are not drawn 955 */ 956 void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, 957 const SkPaint* paint = NULL); 958 959 /** 960 * Specifies coordinates to divide a bitmap into (xCount*yCount) rects. 961 * 962 * If the lattice divs or bounds are invalid, the entire lattice 963 * struct will be ignored on the draw call. 964 */ 965 struct Lattice { 966 enum Flags : uint8_t { 967 // If set, indicates that we should not draw corresponding rect. 968 kTransparent_Flags = 1 << 0, 969 }; 970 971 // An array of x-coordinates that divide the bitmap vertically. 972 // These must be unique, increasing, and in the set [fBounds.fLeft, fBounds.fRight). 973 // Does not have ownership. 974 const int* fXDivs; 975 976 // An array of y-coordinates that divide the bitmap horizontally. 977 // These must be unique, increasing, and in the set [fBounds.fTop, fBounds.fBottom). 978 // Does not have ownership. 979 const int* fYDivs; 980 981 // If non-null, the length of this array must be equal to 982 // (fXCount + 1) * (fYCount + 1). Note that we allow the first rect 983 // in each direction to be empty (ex: fXDivs[0] = fBounds.fLeft). 984 // In this case, the caller still must specify a flag (as a placeholder) 985 // for these empty rects. 986 // The flags correspond to the rects in the lattice, first moving 987 // left to right and then top to bottom. 988 const Flags* fFlags; 989 990 // The number of fXDivs. 991 int fXCount; 992 993 // The number of fYDivs. 994 int fYCount; 995 996 // The bound to draw from. Must be contained by the src that is being drawn, 997 // non-empty, and non-inverted. 998 // If nullptr, the bounds are the entire src. 999 const SkIRect* fBounds; 1000 }; 1001 1002 /** 1003 * Draw the bitmap stretched or shrunk differentially to fit into dst. 1004 * 1005 * Moving horizontally across the bitmap, alternating rects will be "scalable" 1006 * (in the x-dimension) to fit into dst or must be left "fixed". The first rect 1007 * is treated as "fixed", but it's possible to specify an empty first rect by 1008 * making lattice.fXDivs[0] = 0. 1009 * 1010 * The scale factor for all "scalable" rects will be the same, and may be greater 1011 * than or less than 1 (meaning we can stretch or shrink). If the number of 1012 * "fixed" pixels is greater than the width of the dst, we will collapse all of 1013 * the "scalable" regions and appropriately downscale the "fixed" regions. 1014 * 1015 * The same interpretation also applies to the y-dimension. 1016 */ 1017 void drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst, 1018 const SkPaint* paint = nullptr); 1019 void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst, 1020 const SkPaint* paint = nullptr); 1021 1022 /** Draw the text, with origin at (x,y), using the specified paint. 1023 The origin is interpreted based on the Align setting in the paint. 1024 @param text The text to be drawn 1025 @param byteLength The number of bytes to read from the text parameter 1026 @param x The x-coordinate of the origin of the text being drawn 1027 @param y The y-coordinate of the origin of the text being drawn 1028 @param paint The paint used for the text (e.g. color, size, style) 1029 */ 1030 void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, 1031 const SkPaint& paint); 1032 1033 /** Draw the text, with each character/glyph origin specified by the pos[] 1034 array. The origin is interpreted by the Align setting in the paint. 1035 @param text The text to be drawn 1036 @param byteLength The number of bytes to read from the text parameter 1037 @param pos Array of positions, used to position each character 1038 @param paint The paint used for the text (e.g. color, size, style) 1039 */ 1040 void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], 1041 const SkPaint& paint); 1042 1043 /** Draw the text, with each character/glyph origin specified by the x 1044 coordinate taken from the xpos[] array, and the y from the constY param. 1045 The origin is interpreted by the Align setting in the paint. 1046 @param text The text to be drawn 1047 @param byteLength The number of bytes to read from the text parameter 1048 @param xpos Array of x-positions, used to position each character 1049 @param constY The shared Y coordinate for all of the positions 1050 @param paint The paint used for the text (e.g. color, size, style) 1051 */ 1052 void drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, 1053 const SkPaint& paint); 1054 1055 /** Draw the text, with origin at (x,y), using the specified paint, along 1056 the specified path. The paint's Align setting determins where along the 1057 path to start the text. 1058 @param text The text to be drawn 1059 @param byteLength The number of bytes to read from the text parameter 1060 @param path The path the text should follow for its baseline 1061 @param hOffset The distance along the path to add to the text's 1062 starting position 1063 @param vOffset The distance above(-) or below(+) the path to 1064 position the text 1065 @param paint The paint used for the text 1066 */ 1067 void drawTextOnPathHV(const void* text, size_t byteLength, const SkPath& path, SkScalar hOffset, 1068 SkScalar vOffset, const SkPaint& paint); 1069 1070 /** Draw the text, with origin at (x,y), using the specified paint, along 1071 the specified path. The paint's Align setting determins where along the 1072 path to start the text. 1073 @param text The text to be drawn 1074 @param byteLength The number of bytes to read from the text parameter 1075 @param path The path the text should follow for its baseline 1076 @param matrix (may be null) Applied to the text before it is 1077 mapped onto the path 1078 @param paint The paint used for the text 1079 */ 1080 void drawTextOnPath(const void* text, size_t byteLength, const SkPath& path, 1081 const SkMatrix* matrix, const SkPaint& paint); 1082 1083 /** 1084 * Draw the text with each character/glyph individually transformed by its xform. 1085 * If cullRect is not null, it is a conservative bounds of what will be drawn 1086 * taking into account the xforms and the paint, and will be used to accelerate culling. 1087 */ 1088 void drawTextRSXform(const void* text, size_t byteLength, const SkRSXform[], 1089 const SkRect* cullRect, const SkPaint& paint); 1090 1091 /** Draw the text blob, offset by (x,y), using the specified paint. 1092 @param blob The text blob to be drawn 1093 @param x The x-offset of the text being drawn 1094 @param y The y-offset of the text being drawn 1095 @param paint The paint used for the text (e.g. color, size, style) 1096 */ 1097 void drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint); drawTextBlob(const sk_sp<SkTextBlob> & blob,SkScalar x,SkScalar y,const SkPaint & paint)1098 void drawTextBlob(const sk_sp<SkTextBlob>& blob, SkScalar x, SkScalar y, const SkPaint& paint) { 1099 this->drawTextBlob(blob.get(), x, y, paint); 1100 } 1101 1102 /** Draw the picture into this canvas. This method effective brackets the 1103 playback of the picture's draw calls with save/restore, so the state 1104 of this canvas will be unchanged after this call. 1105 @param picture The recorded drawing commands to playback into this 1106 canvas. 1107 */ drawPicture(const SkPicture * picture)1108 void drawPicture(const SkPicture* picture) { 1109 this->drawPicture(picture, NULL, NULL); 1110 } drawPicture(const sk_sp<SkPicture> & picture)1111 void drawPicture(const sk_sp<SkPicture>& picture) { 1112 this->drawPicture(picture.get()); 1113 } 1114 1115 /** 1116 * Draw the picture into this canvas. 1117 * 1118 * If matrix is non-null, apply that matrix to the CTM when drawing this picture. This is 1119 * logically equivalent to 1120 * save/concat/drawPicture/restore 1121 * 1122 * If paint is non-null, draw the picture into a temporary buffer, and then apply the paint's 1123 * alpha/colorfilter/imagefilter/xfermode to that buffer as it is drawn to the canvas. 1124 * This is logically equivalent to 1125 * saveLayer(paint)/drawPicture/restore 1126 */ 1127 void drawPicture(const SkPicture*, const SkMatrix* matrix, const SkPaint* paint); drawPicture(const sk_sp<SkPicture> & picture,const SkMatrix * matrix,const SkPaint * paint)1128 void drawPicture(const sk_sp<SkPicture>& picture, const SkMatrix* matrix, const SkPaint* paint) { 1129 this->drawPicture(picture.get(), matrix, paint); 1130 } 1131 1132 #ifdef SK_EXPERIMENTAL_SHADOWING 1133 /** 1134 * Draw the picture into this canvas, with shadows! 1135 * 1136 * We will use the canvas's lights along with the picture information (draw depths of 1137 * objects, etc) to first create a set of shadowmaps for the light-picture pairs, and 1138 * then use that set of shadowmaps to render the scene with shadows. 1139 * 1140 * If matrix is non-null, apply that matrix to the CTM when drawing this picture. This is 1141 * logically equivalent to 1142 * save/concat/drawPicture/restore 1143 * 1144 * If paint is non-null, draw the picture into a temporary buffer, and then apply the paint's 1145 * alpha/colorfilter/imagefilter/xfermode to that buffer as it is drawn to the canvas. 1146 * This is logically equivalent to 1147 * saveLayer(paint)/drawPicture/restore 1148 * 1149 * We also support using variance shadow maps for blurred shadows; the user can specify 1150 * what shadow mapping algorithm to use with params. 1151 * - Variance Shadow Mapping works by storing both the depth and depth^2 in the shadow map. 1152 * - Then, the shadow map can be blurred, and when reading from it, the fragment shader 1153 * can calculate the variance of the depth at a position by doing E(x^2) - E(x)^2. 1154 * - We can then use the depth variance and depth at a fragment to arrive at an upper bound 1155 * of the probability that the current surface is shadowed by using Chebyshev's 1156 * inequality, and then use that to shade the fragment. 1157 * 1158 * - There are a few problems with VSM. 1159 * * Light Bleeding | Areas with high variance, such as near the edges of high up rects, 1160 * will cause their shadow penumbras to overwrite otherwise solid 1161 * shadows. 1162 * * Shape Distortion | We can combat Light Bleeding by biasing the shadow (setting 1163 * mostly shaded fragments to completely shaded) and increasing 1164 * the minimum allowed variance. However, this warps and rounds 1165 * out the shape of the shadow. 1166 */ 1167 void drawShadowedPicture(const SkPicture*, 1168 const SkMatrix* matrix, 1169 const SkPaint* paint, 1170 const SkShadowParams& params); drawShadowedPicture(const sk_sp<SkPicture> & picture,const SkMatrix * matrix,const SkPaint * paint,const SkShadowParams & params)1171 void drawShadowedPicture(const sk_sp<SkPicture>& picture, 1172 const SkMatrix* matrix, 1173 const SkPaint* paint, 1174 const SkShadowParams& params) { 1175 this->drawShadowedPicture(picture.get(), matrix, paint, params); 1176 } 1177 #endif 1178 1179 enum VertexMode { 1180 kTriangles_VertexMode, 1181 kTriangleStrip_VertexMode, 1182 kTriangleFan_VertexMode 1183 }; 1184 1185 /** Draw the array of vertices, interpreted as triangles (based on mode). 1186 1187 If both textures and vertex-colors are NULL, it strokes hairlines with 1188 the paint's color. This behavior is a useful debugging mode to visualize 1189 the mesh. 1190 1191 @param vmode How to interpret the array of vertices 1192 @param vertexCount The number of points in the vertices array (and 1193 corresponding texs and colors arrays if non-null) 1194 @param vertices Array of vertices for the mesh 1195 @param texs May be null. If not null, specifies the coordinate 1196 in _texture_ space (not uv space) for each vertex. 1197 @param colors May be null. If not null, specifies a color for each 1198 vertex, to be interpolated across the triangle. 1199 @param xmode Used if both texs and colors are present. In this 1200 case the colors are combined with the texture using mode, 1201 before being drawn using the paint. If mode is null, then 1202 kModulate_Mode is used. 1203 @param indices If not null, array of indices to reference into the 1204 vertex (texs, colors) array. 1205 @param indexCount number of entries in the indices array (if not null) 1206 @param paint Specifies the shader/texture if present. 1207 */ 1208 void drawVertices(VertexMode vmode, int vertexCount, 1209 const SkPoint vertices[], const SkPoint texs[], 1210 const SkColor colors[], SkXfermode* xmode, 1211 const uint16_t indices[], int indexCount, 1212 const SkPaint& paint); drawVertices(VertexMode vmode,int vertexCount,const SkPoint vertices[],const SkPoint texs[],const SkColor colors[],const sk_sp<SkXfermode> & xmode,const uint16_t indices[],int indexCount,const SkPaint & paint)1213 void drawVertices(VertexMode vmode, int vertexCount, 1214 const SkPoint vertices[], const SkPoint texs[], 1215 const SkColor colors[], const sk_sp<SkXfermode>& xmode, 1216 const uint16_t indices[], int indexCount, 1217 const SkPaint& paint) { 1218 this->drawVertices(vmode, vertexCount, vertices, texs, colors, xmode.get(), 1219 indices, indexCount, paint); 1220 } 1221 1222 /** 1223 Draw a cubic coons patch 1224 1225 @param cubic specifies the 4 bounding cubic bezier curves of a patch with clockwise order 1226 starting at the top left corner. 1227 @param colors specifies the colors for the corners which will be bilerp across the patch, 1228 their order is clockwise starting at the top left corner. 1229 @param texCoords specifies the texture coordinates that will be bilerp across the patch, 1230 their order is the same as the colors. 1231 @param xmode specifies how are the colors and the textures combined if both of them are 1232 present. 1233 @param paint Specifies the shader/texture if present. 1234 */ 1235 void drawPatch(const SkPoint cubics[12], const SkColor colors[4], 1236 const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint); drawPatch(const SkPoint cubics[12],const SkColor colors[4],const SkPoint texCoords[4],const sk_sp<SkXfermode> & xmode,const SkPaint & paint)1237 void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], 1238 const sk_sp<SkXfermode>& xmode, const SkPaint& paint) { 1239 this->drawPatch(cubics, colors, texCoords, xmode.get(), paint); 1240 } 1241 1242 /** 1243 * Draw a set of sprites from the atlas. Each is specified by a tex rectangle in the 1244 * coordinate space of the atlas, and a corresponding xform which transforms the tex rectangle 1245 * into a quad. 1246 * 1247 * xform maps [0, 0, tex.width, tex.height] -> quad 1248 * 1249 * The color array is optional. When specified, each color modulates the pixels in its 1250 * corresponding quad (via the specified SkXfermode::Mode). 1251 * 1252 * The cullRect is optional. When specified, it must be a conservative bounds of all of the 1253 * resulting transformed quads, allowing the canvas to skip drawing if the cullRect does not 1254 * intersect the current clip. 1255 * 1256 * The paint is optional. If specified, its antialiasing, alpha, color-filter, image-filter 1257 * and xfermode are used to affect each of the quads. 1258 */ 1259 void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], 1260 const SkColor colors[], int count, SkXfermode::Mode, const SkRect* cullRect, 1261 const SkPaint* paint); 1262 drawAtlas(const SkImage * atlas,const SkRSXform xform[],const SkRect tex[],int count,const SkRect * cullRect,const SkPaint * paint)1263 void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count, 1264 const SkRect* cullRect, const SkPaint* paint) { 1265 this->drawAtlas(atlas, xform, tex, NULL, count, SkXfermode::kDst_Mode, cullRect, paint); 1266 } 1267 drawAtlas(const sk_sp<SkImage> & atlas,const SkRSXform xform[],const SkRect tex[],const SkColor colors[],int count,SkXfermode::Mode mode,const SkRect * cull,const SkPaint * paint)1268 void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], 1269 const SkColor colors[], int count, SkXfermode::Mode mode, const SkRect* cull, 1270 const SkPaint* paint) { 1271 this->drawAtlas(atlas.get(), xform, tex, colors, count, mode, cull, paint); 1272 } drawAtlas(const sk_sp<SkImage> & atlas,const SkRSXform xform[],const SkRect tex[],int count,const SkRect * cullRect,const SkPaint * paint)1273 void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], 1274 int count, const SkRect* cullRect, const SkPaint* paint) { 1275 this->drawAtlas(atlas.get(), xform, tex, nullptr, count, SkXfermode::kDst_Mode, 1276 cullRect, paint); 1277 } 1278 1279 /** 1280 * Draw the contents of this drawable into the canvas. If the canvas is async 1281 * (e.g. it is recording into a picture) then the drawable will be referenced instead, 1282 * to have its draw() method called when the picture is finalized. 1283 * 1284 * If the intent is to force the contents of the drawable into this canvas immediately, 1285 * then drawable->draw(canvas) may be called. 1286 */ 1287 void drawDrawable(SkDrawable* drawable, const SkMatrix* = NULL); 1288 void drawDrawable(SkDrawable*, SkScalar x, SkScalar y); 1289 1290 /** 1291 * Send an "annotation" to the canvas. The annotation is a key/value pair, where the key is 1292 * a null-terminated utf8 string, and the value is a blob of data stored in an SkData 1293 * (which may be null). The annotation is associated with the specified rectangle. 1294 * 1295 * The caller still retains its ownership of the data (if any). 1296 * 1297 * Note: on may canvas types, this information is ignored, but some canvases (e.g. recording 1298 * a picture or drawing to a PDF document) will pass on this information. 1299 */ 1300 void drawAnnotation(const SkRect&, const char key[], SkData* value); drawAnnotation(const SkRect & rect,const char key[],const sk_sp<SkData> & value)1301 void drawAnnotation(const SkRect& rect, const char key[], const sk_sp<SkData>& value) { 1302 this->drawAnnotation(rect, key, value.get()); 1303 } 1304 1305 ////////////////////////////////////////////////////////////////////////// 1306 #ifdef SK_INTERNAL 1307 #ifndef SK_SUPPORT_LEGACY_DRAWFILTER 1308 #define SK_SUPPORT_LEGACY_DRAWFILTER 1309 #endif 1310 #endif 1311 1312 #ifdef SK_SUPPORT_LEGACY_DRAWFILTER 1313 /** Get the current filter object. The filter's reference count is not 1314 affected. The filter is saved/restored, just like the matrix and clip. 1315 @return the canvas' filter (or NULL). 1316 */ 1317 SK_ATTR_EXTERNALLY_DEPRECATED("getDrawFilter use is deprecated") 1318 SkDrawFilter* getDrawFilter() const; 1319 1320 /** Set the new filter (or NULL). Pass NULL to clear any existing filter. 1321 As a convenience, the parameter is returned. If an existing filter 1322 exists, its refcnt is decrement. If the new filter is not null, its 1323 refcnt is incremented. The filter is saved/restored, just like the 1324 matrix and clip. 1325 @param filter the new filter (or NULL) 1326 @return the new filter 1327 */ 1328 SK_ATTR_EXTERNALLY_DEPRECATED("setDrawFilter use is deprecated") 1329 virtual SkDrawFilter* setDrawFilter(SkDrawFilter* filter); 1330 #endif 1331 ////////////////////////////////////////////////////////////////////////// 1332 1333 /** 1334 * Return true if the current clip is empty (i.e. nothing will draw). 1335 * Note: this is not always a free call, so it should not be used 1336 * more often than necessary. However, once the canvas has computed this 1337 * result, subsequent calls will be cheap (until the clip state changes, 1338 * which can happen on any clip..() or restore() call. 1339 */ 1340 virtual bool isClipEmpty() const; 1341 1342 /** 1343 * Returns true if the current clip is just a (non-empty) rectangle. 1344 * Returns false if the clip is empty, or if it is complex. 1345 */ 1346 virtual bool isClipRect() const; 1347 1348 /** Return the current matrix on the canvas. 1349 This does not account for the translate in any of the devices. 1350 @return The current matrix on the canvas. 1351 */ 1352 const SkMatrix& getTotalMatrix() const; 1353 1354 /** Return the clip stack. The clip stack stores all the individual 1355 * clips organized by the save/restore frame in which they were 1356 * added. 1357 * @return the current clip stack ("list" of individual clip elements) 1358 */ getClipStack()1359 const SkClipStack* getClipStack() const { 1360 return fClipStack; 1361 } 1362 1363 typedef SkCanvasClipVisitor ClipVisitor; 1364 /** 1365 * Replays the clip operations, back to front, that have been applied to 1366 * the canvas, calling the appropriate method on the visitor for each 1367 * clip. All clips have already been transformed into device space. 1368 */ 1369 void replayClips(ClipVisitor*) const; 1370 1371 /////////////////////////////////////////////////////////////////////////// 1372 1373 // don't call 1374 GrDrawContext* internal_private_accessTopLayerDrawContext(); 1375 1376 // don't call 1377 static void Internal_Private_SetIgnoreSaveLayerBounds(bool); 1378 static bool Internal_Private_GetIgnoreSaveLayerBounds(); 1379 static void Internal_Private_SetTreatSpriteAsBitmap(bool); 1380 static bool Internal_Private_GetTreatSpriteAsBitmap(); 1381 1382 // TEMP helpers until we switch virtual over to const& for src-rect 1383 void legacy_drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, 1384 const SkPaint* paint, 1385 SrcRectConstraint constraint = kStrict_SrcRectConstraint); 1386 void legacy_drawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst, 1387 const SkPaint* paint, 1388 SrcRectConstraint constraint = kStrict_SrcRectConstraint); 1389 1390 // expose minimum amount of information necessary for transitional refactoring 1391 /** 1392 * Returns CTM and clip bounds, translated from canvas coordinates to top layer coordinates. 1393 */ 1394 void temporary_internal_describeTopLayer(SkMatrix* matrix, SkIRect* clip_bounds); 1395 1396 protected: 1397 #ifdef SK_EXPERIMENTAL_SHADOWING 1398 /** Returns the current (cumulative) draw depth of the canvas. 1399 */ 1400 SkScalar getZ() const; 1401 1402 sk_sp<SkLights> fLights; 1403 #endif 1404 1405 // default impl defers to getDevice()->newSurface(info) 1406 virtual sk_sp<SkSurface> onNewSurface(const SkImageInfo&, const SkSurfaceProps&); 1407 1408 // default impl defers to its device 1409 virtual bool onPeekPixels(SkPixmap*); 1410 virtual bool onAccessTopLayerPixels(SkPixmap*); 1411 virtual SkImageInfo onImageInfo() const; 1412 virtual bool onGetProps(SkSurfaceProps*) const; 1413 virtual void onFlush(); 1414 1415 // Subclass save/restore notifiers. 1416 // Overriders should call the corresponding INHERITED method up the inheritance chain. 1417 // getSaveLayerStrategy()'s return value may suppress full layer allocation. 1418 enum SaveLayerStrategy { 1419 kFullLayer_SaveLayerStrategy, 1420 kNoLayer_SaveLayerStrategy, 1421 }; 1422 willSave()1423 virtual void willSave() {} 1424 // Overriders should call the corresponding INHERITED method up the inheritance chain. getSaveLayerStrategy(const SaveLayerRec &)1425 virtual SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec&) { 1426 return kFullLayer_SaveLayerStrategy; 1427 } willRestore()1428 virtual void willRestore() {} didRestore()1429 virtual void didRestore() {} didConcat(const SkMatrix &)1430 virtual void didConcat(const SkMatrix&) {} didSetMatrix(const SkMatrix &)1431 virtual void didSetMatrix(const SkMatrix&) {} didTranslate(SkScalar dx,SkScalar dy)1432 virtual void didTranslate(SkScalar dx, SkScalar dy) { 1433 this->didConcat(SkMatrix::MakeTrans(dx, dy)); 1434 } 1435 1436 #ifdef SK_EXPERIMENTAL_SHADOWING didTranslateZ(SkScalar)1437 virtual void didTranslateZ(SkScalar) {} 1438 #endif 1439 1440 virtual void onDrawAnnotation(const SkRect&, const char key[], SkData* value); 1441 virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&); 1442 1443 virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, 1444 SkScalar y, const SkPaint& paint); 1445 1446 virtual void onDrawPosText(const void* text, size_t byteLength, 1447 const SkPoint pos[], const SkPaint& paint); 1448 1449 virtual void onDrawPosTextH(const void* text, size_t byteLength, 1450 const SkScalar xpos[], SkScalar constY, 1451 const SkPaint& paint); 1452 1453 virtual void onDrawTextOnPath(const void* text, size_t byteLength, 1454 const SkPath& path, const SkMatrix* matrix, 1455 const SkPaint& paint); 1456 virtual void onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform[], 1457 const SkRect* cullRect, const SkPaint& paint); 1458 1459 virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, 1460 const SkPaint& paint); 1461 1462 virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4], 1463 const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint); 1464 1465 virtual void onDrawDrawable(SkDrawable*, const SkMatrix*); 1466 1467 virtual void onDrawPaint(const SkPaint&); 1468 virtual void onDrawRect(const SkRect&, const SkPaint&); 1469 virtual void onDrawRegion(const SkRegion& region, const SkPaint& paint); 1470 virtual void onDrawOval(const SkRect&, const SkPaint&); 1471 virtual void onDrawArc(const SkRect&, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, 1472 const SkPaint&); 1473 virtual void onDrawRRect(const SkRRect&, const SkPaint&); 1474 virtual void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&); 1475 virtual void onDrawVertices(VertexMode, int vertexCount, const SkPoint vertices[], 1476 const SkPoint texs[], const SkColor colors[], SkXfermode*, 1477 const uint16_t indices[], int indexCount, const SkPaint&); 1478 1479 virtual void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], 1480 int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*); 1481 virtual void onDrawPath(const SkPath&, const SkPaint&); 1482 virtual void onDrawImage(const SkImage*, SkScalar dx, SkScalar dy, const SkPaint*); 1483 virtual void onDrawImageRect(const SkImage*, const SkRect*, const SkRect&, const SkPaint*, 1484 SrcRectConstraint); 1485 virtual void onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst, 1486 const SkPaint*); 1487 virtual void onDrawImageLattice(const SkImage*, const Lattice& lattice, const SkRect& dst, 1488 const SkPaint*); 1489 1490 virtual void onDrawBitmap(const SkBitmap&, SkScalar dx, SkScalar dy, const SkPaint*); 1491 virtual void onDrawBitmapRect(const SkBitmap&, const SkRect*, const SkRect&, const SkPaint*, 1492 SrcRectConstraint); 1493 virtual void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst, 1494 const SkPaint*); 1495 virtual void onDrawBitmapLattice(const SkBitmap&, const Lattice& lattice, const SkRect& dst, 1496 const SkPaint*); 1497 1498 enum ClipEdgeStyle { 1499 kHard_ClipEdgeStyle, 1500 kSoft_ClipEdgeStyle 1501 }; 1502 1503 virtual void onClipRect(const SkRect& rect, ClipOp, ClipEdgeStyle); 1504 virtual void onClipRRect(const SkRRect& rrect, ClipOp, ClipEdgeStyle); 1505 virtual void onClipPath(const SkPath& path, ClipOp, ClipEdgeStyle); 1506 virtual void onClipRegion(const SkRegion& deviceRgn, ClipOp); 1507 1508 virtual void onDiscard(); 1509 1510 virtual void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*); 1511 1512 #ifdef SK_EXPERIMENTAL_SHADOWING 1513 virtual void onDrawShadowedPicture(const SkPicture*, 1514 const SkMatrix*, 1515 const SkPaint*, 1516 const SkShadowParams& params); 1517 #endif 1518 1519 // Returns the canvas to be used by DrawIter. Default implementation 1520 // returns this. Subclasses that encapsulate an indirect canvas may 1521 // need to overload this method. The impl must keep track of this, as it 1522 // is not released or deleted by the caller. 1523 virtual SkCanvas* canvasForDrawIter(); 1524 1525 // Clip rectangle bounds. Called internally by saveLayer. 1526 // returns false if the entire rectangle is entirely clipped out 1527 // If non-NULL, The imageFilter parameter will be used to expand the clip 1528 // and offscreen bounds for any margin required by the filter DAG. 1529 bool clipRectBounds(const SkRect* bounds, SaveLayerFlags, SkIRect* intersection, 1530 const SkImageFilter* imageFilter = NULL); 1531 1532 private: 1533 /** After calling saveLayer(), there can be any number of devices that make 1534 up the top-most drawing area. LayerIter can be used to iterate through 1535 those devices. Note that the iterator is only valid until the next API 1536 call made on the canvas. Ownership of all pointers in the iterator stays 1537 with the canvas, so none of them should be modified or deleted. 1538 */ 1539 class LayerIter /*: SkNoncopyable*/ { 1540 public: 1541 /** Initialize iterator with canvas, and set values for 1st device */ 1542 LayerIter(SkCanvas*); 1543 ~LayerIter(); 1544 1545 /** Return true if the iterator is done */ done()1546 bool done() const { return fDone; } 1547 /** Cycle to the next device */ 1548 void next(); 1549 1550 // These reflect the current device in the iterator 1551 1552 SkBaseDevice* device() const; 1553 const SkMatrix& matrix() const; 1554 const SkRasterClip& clip() const; 1555 const SkPaint& paint() const; 1556 int x() const; 1557 int y() const; 1558 1559 private: 1560 // used to embed the SkDrawIter object directly in our instance, w/o 1561 // having to expose that class def to the public. There is an assert 1562 // in our constructor to ensure that fStorage is large enough 1563 // (though needs to be a compile-time-assert!). We use intptr_t to work 1564 // safely with 32 and 64 bit machines (to ensure the storage is enough) 1565 intptr_t fStorage[32]; 1566 class SkDrawIter* fImpl; // this points at fStorage 1567 SkPaint fDefaultPaint; 1568 bool fDone; 1569 }; 1570 1571 static bool BoundsAffectsClip(SaveLayerFlags); 1572 static SaveLayerFlags LegacySaveFlagsToSaveLayerFlags(uint32_t legacySaveFlags); 1573 1574 static void DrawDeviceWithFilter(SkBaseDevice* src, const SkImageFilter* filter, 1575 SkBaseDevice* dst, const SkMatrix& ctm, 1576 const SkClipStack* clipStack); 1577 1578 enum ShaderOverrideOpacity { 1579 kNone_ShaderOverrideOpacity, //!< there is no overriding shader (bitmap or image) 1580 kOpaque_ShaderOverrideOpacity, //!< the overriding shader is opaque 1581 kNotOpaque_ShaderOverrideOpacity, //!< the overriding shader may not be opaque 1582 }; 1583 1584 // notify our surface (if we have one) that we are about to draw, so it 1585 // can perform copy-on-write or invalidate any cached images 1586 void predrawNotify(bool willOverwritesEntireSurface = false); 1587 void predrawNotify(const SkRect* rect, const SkPaint* paint, ShaderOverrideOpacity); predrawNotify(const SkRect * rect,const SkPaint * paint,bool shaderOverrideIsOpaque)1588 void predrawNotify(const SkRect* rect, const SkPaint* paint, bool shaderOverrideIsOpaque) { 1589 this->predrawNotify(rect, paint, shaderOverrideIsOpaque ? kOpaque_ShaderOverrideOpacity 1590 : kNotOpaque_ShaderOverrideOpacity); 1591 } 1592 1593 class MCRec; 1594 1595 SkAutoTUnref<SkClipStack> fClipStack; 1596 SkDeque fMCStack; 1597 // points to top of stack 1598 MCRec* fMCRec; 1599 // the first N recs that can fit here mean we won't call malloc 1600 enum { 1601 kMCRecSize = 128, // most recent measurement 1602 kMCRecCount = 32, // common depth for save/restores 1603 kDeviceCMSize = 176, // most recent measurement 1604 }; 1605 intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)]; 1606 intptr_t fDeviceCMStorage[kDeviceCMSize / sizeof(intptr_t)]; 1607 1608 const SkSurfaceProps fProps; 1609 1610 int fSaveCount; // value returned by getSaveCount() 1611 1612 SkMetaData* fMetaData; 1613 1614 SkSurface_Base* fSurfaceBase; getSurfaceBase()1615 SkSurface_Base* getSurfaceBase() const { return fSurfaceBase; } setSurfaceBase(SkSurface_Base * sb)1616 void setSurfaceBase(SkSurface_Base* sb) { 1617 fSurfaceBase = sb; 1618 } 1619 friend class SkSurface_Base; 1620 friend class SkSurface_Gpu; 1621 1622 bool fDeviceCMDirty; // cleared by updateDeviceCMCache() 1623 void updateDeviceCMCache(); 1624 1625 void doSave(); 1626 void checkForDeferredSave(); 1627 void internalSetMatrix(const SkMatrix&); 1628 1629 friend class SkDrawIter; // needs setupDrawForLayerDevice() 1630 friend class AutoDrawLooper; 1631 friend class SkLua; // needs top layer size and offset 1632 friend class SkDebugCanvas; // needs experimental fAllowSimplifyClip 1633 friend class SkSurface_Raster; // needs getDevice() 1634 friend class SkRecorder; // InitFlags 1635 friend class SkLiteRecorder; // InitFlags 1636 friend class SkNoSaveLayerCanvas; // InitFlags 1637 friend class SkPictureImageFilter; // SkCanvas(SkBaseDevice*, SkSurfaceProps*, InitFlags) 1638 friend class SkPictureRecord; // predrawNotify (why does it need it? <reed>) 1639 friend class SkPicturePlayback; // SaveFlagsToSaveLayerFlags 1640 1641 enum InitFlags { 1642 kDefault_InitFlags = 0, 1643 kConservativeRasterClip_InitFlag = 1 << 0, 1644 }; 1645 SkCanvas(const SkIRect& bounds, InitFlags); 1646 SkCanvas(SkBaseDevice* device, InitFlags); 1647 1648 void resetForNextPicture(const SkIRect& bounds); 1649 1650 // needs gettotalclip() 1651 friend class SkCanvasStateUtils; 1652 1653 // call this each time we attach ourselves to a device 1654 // - constructor 1655 // - internalSaveLayer 1656 void setupDevice(SkBaseDevice*); 1657 1658 SkBaseDevice* init(SkBaseDevice*, InitFlags); 1659 1660 /** 1661 * Gets the bounds of the top level layer in global canvas coordinates. We don't want this 1662 * to be public because it exposes decisions about layer sizes that are internal to the canvas. 1663 */ 1664 SkIRect getTopLayerBounds() const; 1665 1666 void internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, 1667 const SkRect& dst, const SkPaint* paint, 1668 SrcRectConstraint); 1669 void internalDrawPaint(const SkPaint& paint); 1670 void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy); 1671 void internalDrawDevice(SkBaseDevice*, int x, int y, const SkPaint*); 1672 1673 // shared by save() and saveLayer() 1674 void internalSave(); 1675 void internalRestore(); 1676 static void DrawRect(const SkDraw& draw, const SkPaint& paint, 1677 const SkRect& r, SkScalar textSize); 1678 static void DrawTextDecorations(const SkDraw& draw, const SkPaint& paint, 1679 const char text[], size_t byteLength, 1680 SkScalar x, SkScalar y); 1681 1682 // only for canvasutils 1683 const SkRegion& internal_private_getTotalClip() const; 1684 1685 /* 1686 * Returns true if drawing the specified rect (or all if it is null) with the specified 1687 * paint (or default if null) would overwrite the entire root device of the canvas 1688 * (i.e. the canvas' surface if it had one). 1689 */ 1690 bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*, ShaderOverrideOpacity) const; 1691 1692 /** 1693 * Returns true if the paint's imagefilter can be invoked directly, without needed a layer. 1694 */ 1695 bool canDrawBitmapAsSprite(SkScalar x, SkScalar y, int w, int h, const SkPaint&); 1696 1697 1698 /** 1699 * Keep track of the device clip bounds and if the matrix is scale-translate. This allows 1700 * us to do a fast quick reject in the common case. 1701 */ 1702 bool fIsScaleTranslate; 1703 SkRect fDeviceClipBounds; 1704 1705 bool fAllowSoftClip; 1706 bool fAllowSimplifyClip; 1707 const bool fConservativeRasterClip; 1708 1709 class AutoValidateClip : ::SkNoncopyable { 1710 public: AutoValidateClip(SkCanvas * canvas)1711 explicit AutoValidateClip(SkCanvas* canvas) : fCanvas(canvas) { 1712 fCanvas->validateClip(); 1713 } ~AutoValidateClip()1714 ~AutoValidateClip() { fCanvas->validateClip(); } 1715 1716 private: 1717 const SkCanvas* fCanvas; 1718 }; 1719 1720 #ifdef SK_DEBUG 1721 void validateClip() const; 1722 #else validateClip()1723 void validateClip() const {} 1724 #endif 1725 1726 typedef SkRefCnt INHERITED; 1727 }; 1728 1729 /** Stack helper class to automatically call restoreToCount() on the canvas 1730 when this object goes out of scope. Use this to guarantee that the canvas 1731 is restored to a known state. 1732 */ 1733 class SkAutoCanvasRestore : SkNoncopyable { 1734 public: SkAutoCanvasRestore(SkCanvas * canvas,bool doSave)1735 SkAutoCanvasRestore(SkCanvas* canvas, bool doSave) : fCanvas(canvas), fSaveCount(0) { 1736 if (fCanvas) { 1737 fSaveCount = canvas->getSaveCount(); 1738 if (doSave) { 1739 canvas->save(); 1740 } 1741 } 1742 } ~SkAutoCanvasRestore()1743 ~SkAutoCanvasRestore() { 1744 if (fCanvas) { 1745 fCanvas->restoreToCount(fSaveCount); 1746 } 1747 } 1748 1749 /** 1750 * Perform the restore now, instead of waiting for the destructor. Will 1751 * only do this once. 1752 */ restore()1753 void restore() { 1754 if (fCanvas) { 1755 fCanvas->restoreToCount(fSaveCount); 1756 fCanvas = NULL; 1757 } 1758 } 1759 1760 private: 1761 SkCanvas* fCanvas; 1762 int fSaveCount; 1763 }; 1764 #define SkAutoCanvasRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoCanvasRestore) 1765 1766 class SkCanvasClipVisitor { 1767 public: 1768 virtual ~SkCanvasClipVisitor(); 1769 virtual void clipRect(const SkRect&, SkCanvas::ClipOp, bool antialias) = 0; 1770 virtual void clipRRect(const SkRRect&, SkCanvas::ClipOp, bool antialias) = 0; 1771 virtual void clipPath(const SkPath&, SkCanvas::ClipOp, bool antialias) = 0; 1772 }; 1773 1774 #endif 1775