0ac0eddd88
removed SrcRectConstraint from docs to match SkCanvas.h also removed constraint description paragraph from SkCanvas.h TBR=bsalomon@google.com Docs-Preview: https://skia.org/?cl=165821 Bug: skia:5679 Change-Id: I34c51f672477076f182946ce71e2d06f049e7f29 Reviewed-on: https://skia-review.googlesource.com/c/165821 Commit-Queue: Cary Clark <caryclark@skia.org> Auto-Submit: Cary Clark <caryclark@skia.org> Reviewed-by: Brian Salomon <bsalomon@google.com> Reviewed-by: Cary Clark <caryclark@skia.org>
403 KiB
SkCanvas Reference
class SkCanvas { public: static std::unique_ptr<SkCanvas> MakeRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes, const SkSurfaceProps* props = nullptr); static std::unique_ptr<SkCanvas> MakeRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes); SkCanvas(); SkCanvas(int width, int height, const SkSurfaceProps* props = nullptr); explicit SkCanvas(sk_sp device); explicit SkCanvas(const SkBitmap& bitmap); enum class ColorBehavior { kLegacy, }; SkCanvas(const SkBitmap& bitmap, ColorBehavior behavior); SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props); virtual ~SkCanvas(); SkMetaData& getMetaData(); SkImageInfo imageInfo() const; bool getProps(SkSurfaceProps* props) const; void flush(); virtual SkISize getBaseLayerSize() const; sk_sp<SkSurface> makeSurface(const SkImageInfo& info, const SkSurfaceProps* props = nullptr); virtual GrContext* getGrContext(); void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin = nullptr); SkRasterHandleAllocator::Handle accessTopRasterHandle() const; bool peekPixels(SkPixmap* pixmap); bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY); bool readPixels(const SkPixmap& pixmap, int srcX, int srcY); bool readPixels(const SkBitmap& bitmap, int srcX, int srcY); bool writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y); bool writePixels(const SkBitmap& bitmap, int x, int y); int save(); int saveLayer(const SkRect* bounds, const SkPaint* paint); int saveLayer(const SkRect& bounds, const SkPaint* paint); int saveLayerPreserveLCDTextRequests(const SkRect* bounds, const SkPaint* paint); int saveLayerAlpha(const SkRect* bounds, U8CPU alpha); enum SaveLayerFlagsSet { kPreserveLCDText_SaveLayerFlag = 1 << 1, kInitWithPrevious_SaveLayerFlag = 1 << 2, kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag = 1 << 3, kDontClipToLayer_Legacy_SaveLayerFlag = kDontClipToLayer_PrivateSaveLayerFlag, }; typedef uint32_t SaveLayerFlags; struct SaveLayerRec { SaveLayerRec(); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, SaveLayerFlags saveLayerFlags); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, const SkImage* clipMask, const SkMatrix* clipMatrix, SaveLayerFlags saveLayerFlags); const SkRect* fBounds = nullptr; const SkPaint* fPaint = nullptr; const SkImageFilter* fBackdrop = nullptr; const SkImage* fClipMask = nullptr; const SkMatrix* fClipMatrix = nullptr; SaveLayerFlags fSaveLayerFlags = 0; }; int saveLayer(const SaveLayerRec& layerRec); void restore(); int getSaveCount() const; void restoreToCount(int saveCount); void translate(SkScalar dx, SkScalar dy); void scale(SkScalar sx, SkScalar sy); void rotate(SkScalar degrees); void rotate(SkScalar degrees, SkScalar px, SkScalar py); void skew(SkScalar sx, SkScalar sy); void concat(const SkMatrix& matrix); void setMatrix(const SkMatrix& matrix); void resetMatrix(); void clipRect(const SkRect& rect, SkClipOp op, bool doAntiAlias); void clipRect(const SkRect& rect, SkClipOp op); void clipRect(const SkRect& rect, bool doAntiAlias = false); void androidFramework_setDeviceClipRestriction(const SkIRect& rect); void clipRRect(const SkRRect& rrect, SkClipOp op, bool doAntiAlias); void clipRRect(const SkRRect& rrect, SkClipOp op); void clipRRect(const SkRRect& rrect, bool doAntiAlias = false); void clipPath(const SkPath& path, SkClipOp op, bool doAntiAlias); void clipPath(const SkPath& path, SkClipOp op); void clipPath(const SkPath& path, bool doAntiAlias = false); void setAllowSimplifyClip(bool allow); void clipRegion(const SkRegion& deviceRgn, SkClipOp op = SkClipOp::kIntersect); bool quickReject(const SkRect& rect) const; bool quickReject(const SkPath& path) const; SkRect getLocalClipBounds() const; bool getLocalClipBounds(SkRect* bounds) const; SkIRect getDeviceClipBounds() const; bool getDeviceClipBounds(SkIRect* bounds) const; void drawColor(SkColor color, SkBlendMode mode = SkBlendMode::kSrcOver); void clear(SkColor color); void discard(); void drawPaint(const SkPaint& paint); enum PointMode { kPoints_PointMode, kLines_PointMode, kPolygon_PointMode, }; void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint); void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint); void drawPoint(SkPoint p, const SkPaint& paint); void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint); void drawLine(SkPoint p0, SkPoint p1, const SkPaint& paint); void drawRect(const SkRect& rect, const SkPaint& paint); void drawIRect(const SkIRect& rect, const SkPaint& paint); void drawRegion(const SkRegion& region, const SkPaint& paint); void drawOval(const SkRect& oval, const SkPaint& paint); void drawRRect(const SkRRect& rrect, const SkPaint& paint); void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint); void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint); void drawCircle(SkPoint center, SkScalar radius, const SkPaint& paint); void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint); void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, const SkPaint& paint); void drawPath(const SkPath& path, const SkPaint& paint); void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr); void drawImage(const sk_sp<SkImage>& image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr); enum SrcRectConstraint { kStrict_SrcRectConstraint, kFast_SrcRectConstraint, }; void drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint); void drawImageRect(const sk_sp<SkImage>& image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawImageRect(const sk_sp<SkImage>& image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawImageRect(const sk_sp<SkImage>& image, const SkRect& dst, const SkPaint* paint); void drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr); void drawImageNine(const sk_sp<SkImage>& image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr); void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint = nullptr); void drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint); void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr); struct Lattice { enum RectType : uint8_t { kDefault = 0, kTransparent, kFixedColor, }; const int* fXDivs; const int* fYDivs; const RectType* fRectTypes; int fXCount; int fYCount; const SkIRect* fBounds; const SkColor* fColors; }; void drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr); void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr); enum QuadAAFlags : unsigned { kLeft_QuadAAFlag = 0b0001, kTop_QuadAAFlag = 0b0010, kRight_QuadAAFlag = 0b0100, kBottom_QuadAAFlag = 0b1000, kNone_QuadAAFlags = 0b0000, kAll_QuadAAFlags = 0b1111, }; struct ImageSetEntry { sk_spSkImage> fImage; SkRect fSrcRect; SkRect fDstRect; unsigned fAAFlags; }; void experimental_DrawImageSetV0(const ImageSetEntry imageSet[], int cnt, float alpha, SkFilterQuality quality, SkBlendMode mode); void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint); void drawString(const char* string, SkScalar x, SkScalar y, const SkPaint& paint); void drawString(const SkString& string, SkScalar x, SkScalar y, const SkPaint& paint); void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint& paint); void drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, const SkPaint& paint); void drawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[], const SkRect* cullRect, const SkPaint& paint); void drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint); void drawTextBlob(const sk_sp<SkTextBlob>& blob, SkScalar x, SkScalar y, const SkPaint& paint); void drawPicture(const SkPicture* picture); void drawPicture(const sk_sp<SkPicture>& picture); void drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint); void drawPicture(const sk_sp<SkPicture>& picture, const SkMatrix* matrix, const SkPaint* paint); void drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint); void drawVertices(const sk_sp<SkVertices>& vertices, SkBlendMode mode, const SkPaint& paint); void drawVertices(const SkVertices* vertices, const SkVertices::Bone bones[], int boneCount, SkBlendMode mode, const SkPaint& paint); void drawVertices(const sk_sp<SkVertices>& vertices, const SkVertices::Bone bones[], int boneCount, SkBlendMode mode, const SkPaint& paint); void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint); void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], const SkPaint& paint); void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint); void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint); void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint); void drawAtlas(const sk_sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint); void drawDrawable(SkDrawable* drawable, const SkMatrix* matrix = nullptr); void drawDrawable(SkDrawable* drawable, SkScalar x, SkScalar y); void drawAnnotation(const SkRect& rect, const char key[], SkData* value); void drawAnnotation(const SkRect& rect, const char key[], const sk_sp<SkData>& value); virtual bool isClipEmpty() const; virtual bool isClipRect() const; const SkMatrix& getTotalMatrix() const; };
Canvas provides an interface for drawing, and how the drawing is clipped and transformed. Canvas contains a stack of Matrix and Clip values.
Canvas and Paint together provide the state to draw into Surface or Device. Each Canvas draw call transforms the geometry of the object by the concatenation of all Matrix values in the stack. The transformed geometry is clipped by the intersection of all of Clip values in the stack. The Canvas draw calls use Paint to supply drawing state such as Color, Typeface, text size, stroke width, Shader and so on.
To draw to a pixel-based destination, create Raster Surface or GPU Surface. Request Canvas from Surface to obtain the interface to draw. Canvas generated by Raster Surface draws to memory visible to the CPU. Canvas generated by GPU Surface uses Vulkan or OpenGL to draw to the GPU.
To draw to a document, obtain Canvas from SVG Canvas, Document PDF, or Picture Recorder. Document based Canvas and other Canvas Subclasses reference Device describing the destination.
Canvas can be constructed to draw to Bitmap without first creating Raster Surface. This approach may be deprecated in the future.
Create the desired type of Surface to obtain its Canvas when possible. Useful when no Surface is required, and some helpers implicitly create Raster Surface.
static std::unique_ptr<SkCanvas> MakeRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes, const SkSurfaceProps* props = nullptr)
Allocates raster Canvas that will draw directly into pixels.
Canvas is returned if all parameters are valid. Valid parameters include: info dimensions are zero or positive; info contains Color Type and Alpha Type supported by Raster Surface; pixels is not nullptr; rowBytes is zero or large enough to contain info width pixels of Color Type.
Pass zero for rowBytes to compute rowBytes from info width and size of pixel. If rowBytes is greater than zero, it must be equal to or greater than info width times bytes required for Color Type.
Pixel buffer size should be info height times computed rowBytes. Pixels are not initialized. To access pixels after drawing, call flush() or peekPixels.
Parameters
info |
width, height, Color Type, Alpha Type, Color Space, of Raster Surface; width, or height, or both, may be zero |
pixels |
pointer to destination pixels buffer |
rowBytes |
interval from one Surface row to the next, or zero |
props |
LCD striping orientation and setting for device independent fonts; may be nullptr |
Return Value
Canvas if all parameters are valid; otherwise, nullptr
Example
Example Output
---
-x-
---
See Also
MakeRasterDirectN32 SkSurface::MakeRasterDirect
static std::unique_ptr<SkCanvas> MakeRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes)
Allocates raster Canvas specified by inline image specification. Subsequent Canvas calls draw into pixels. Color Type is set to kN32_SkColorType. Alpha Type is set to kPremul_SkAlphaType. To access pixels after drawing, call flush() or peekPixels.
Canvas is returned if all parameters are valid. Valid parameters include: width and height are zero or positive; pixels is not nullptr; rowBytes is zero or large enough to contain width pixels of kN32_SkColorType.
Pass zero for rowBytes to compute rowBytes from width and size of pixel. If rowBytes is greater than zero, it must be equal to or greater than width times bytes required for Color Type.
Pixel buffer size should be height times rowBytes.
Parameters
width |
pixel column count on Raster Surface created; must be zero or greater |
height |
pixel row count on Raster Surface created; must be zero or greater |
pixels |
pointer to destination pixels buffer; buffer size should be height times rowBytes |
rowBytes |
interval from one Surface row to the next, or zero |
Return Value
Canvas if all parameters are valid; otherwise, nullptr
Example
Example Output
---
-x-
---
See Also
MakeRasterDirect SkSurface::MakeRasterDirect SkImageInfo::MakeN32Premul[2]
SkCanvas()
Creates an empty Canvas with no backing device or pixels, with a width and height of zero.
Return Value
empty Canvas
Example
Example Output
rect stays rect is true
rect stays rect is false
rect stays rect is true
See Also
MakeRasterDirect SkRasterHandleAllocator::MakeCanvas SkSurface::getCanvas SkCreateColorSpaceXformCanvas
SkCanvas(int width, int height, const SkSurfaceProps* props = nullptr)
Creates Canvas of the specified dimensions without a Surface. Used by Subclasses with custom implementations for draw member functions.
If props equals nullptr, Surface Properties are created with Surface Properties Legacy Font Host settings, which choose the pixel striping direction and order. Since a platform may dynamically change its direction when the device is rotated, and since a platform may have multiple monitors with different characteristics, it is best not to rely on this legacy behavior.
Parameters
width |
zero or greater |
height |
zero or greater |
props |
LCD striping orientation and setting for device independent fonts; may be nullptr |
Return Value
Canvas placeholder with dimensions
Example
Example Output
canvas is empty
See Also
MakeRasterDirect SkSurfaceProps SkPixelGeometry SkCreateColorSpaceXformCanvas
explicit SkCanvas(sk sp<SkBaseDevice> device)
To be deprecated soon.
explicit SkCanvas(const SkBitmap& bitmap)
Constructs a canvas that draws into bitmap. Sets SkSurfaceProps::kLegacyFontHost InitType in constructed Surface.
Bitmap is copied so that subsequently editing bitmap will not affect constructed Canvas.
May be deprecated in the future.
Parameters
bitmap |
width, height, Color Type, Alpha Type, and pixel storage of Raster Surface |
Return Value
Canvas that can be used to draw into bitmap
Example
Example Output
-----
---x-
---x-
---x-
---x-
---x-
---x-
-----
---x-
---x-
-----
See Also
MakeRasterDirect SkRasterHandleAllocator::MakeCanvas SkSurface::getCanvas SkCreateColorSpaceXformCanvas
Private: Android framework only.
enum class ColorBehavior { kLegacy, };
Constants
| Const | Value | Description |
|---|---|---|
SkCanvas::ColorBehavior::kLegacy |
0 | Is a placeholder to allow specialized constructor; has no meaning. |
SkCanvas(const SkBitmap& bitmap, ColorBehavior behavior)
For use by Android framework only.
Parameters
bitmap |
specifies a bitmap for the canvas to draw into |
behavior |
specializes this constructor; value is unused |
Return Value
Canvas that can be used to draw into bitmap
SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props)
Constructs a canvas that draws into bitmap. Use props to match the device characteristics, like LCD striping.
bitmap is copied so that subsequently editing bitmap will not affect constructed Canvas.
Parameters
bitmap |
width, height, Color Type, Alpha Type, and pixel storage of Raster Surface |
props |
order and orientation of RGB striping; and whether to use device independent fonts |
Return Value
Canvas that can be used to draw into bitmap
Example
Example Output
-----
---x-
---x-
---x-
---x-
---x-
---x-
-----
---x-
---x-
-----
See Also
MakeRasterDirect SkRasterHandleAllocator::MakeCanvas SkSurface::getCanvas SkCreateColorSpaceXformCanvas
virtual ~SkCanvas()
Draws saved Layers, if any. Frees up resources used by Canvas.
Example
See Also
SkMetaData& getMetaData()
Returns storage to associate additional data with the canvas. The storage is freed when Canvas is deleted.
Return Value
storage that can be read from and written to
Example
Example Output
before: (null)
during: Hello!
after: (null)
See Also
SkImageInfo imageInfo() const
Returns Image Info for Canvas. If Canvas is not associated with Raster Surface or GPU Surface, returned Color Type is set to kUnknown_SkColorType.
Return Value
dimensions and Color Type of Canvas
Example
Example Output
emptyInfo == canvasInfo
See Also
SkImageInfo MakeRasterDirect makeSurface
bool getProps(SkSurfaceProps* props) const
Copies Surface Properties, if Canvas is associated with Raster Surface or GPU Surface, and returns true. Otherwise, returns false and leave props unchanged.
Parameters
props |
storage for writable SkSurfaceProps |
Return Value
true if Surface Properties was copied
Example
Example Output
isRGB:0
isRGB:1
See Also
void flush()
Triggers the immediate execution of all pending draw operations. If Canvas is associated with GPU Surface, resolves all pending GPU operations. If Canvas is associated with Raster Surface, has no effect; raster draw operations are never deferred.
See Also
peekPixels SkSurface::flush() GrContext::flush() SkSurface::prepareForExternalIO GrContext::abandonContext()
virtual SkISize getBaseLayerSize() const
Gets the size of the base or root Layer in global canvas coordinates. The origin of the base Layer is always (0,0). The area available for drawing may be smaller (due to clipping or saveLayer).
Return Value
integral width and height of base Layer
Example
Example Output
clip=10,30
size=20,30
See Also
sk sp<SkSurface> makeSurface(const SkImageInfo& info, const SkSurfaceProps* props = nullptr)
Creates Surface matching info and props, and associates it with Canvas. Returns nullptr if no match found.
If props is nullptr, matches Surface Properties in Canvas. If props is nullptr and Canvas does not have Surface Properties, creates Surface with default Surface Properties.
Parameters
info |
width, height, Color Type, Alpha Type, and Color Space |
props |
Surface Properties to match; may be nullptr to match Canvas |
Return Value
Surface matching info and props, or nullptr if no match is available
Example
Example Output
compatible != nullptr
size = 3, 4
See Also
SkSurface SkSurface::makeSurface SkImageInfo SkSurfaceProps
virtual GrContext* getGrContext()
Returns GPU Context of the GPU Surface associated with Canvas.
Return Value
GPU Context, if available; nullptr otherwise
Example
See Also
void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin = nullptr)
Returns the pixel base address, Image Info, rowBytes, and origin if the pixels can be read directly. The returned address is only valid while Canvas is in scope and unchanged. Any Canvas call or Surface call may invalidate the returned address and other returned values.
If pixels are inaccessible, info, rowBytes, and origin are unchanged.
Parameters
info |
storage for writable pixels' Image Info; may be nullptr |
rowBytes |
storage for writable pixels' row bytes; may be nullptr |
origin |
storage for Canvas top Layer origin, its top-left corner; may be nullptr |
Return Value
address of pixels, or nullptr if inaccessible
Example
Example
See Also
SkRasterHandleAllocator::Handle accessTopRasterHandle() const
Returns custom context that tracks the Matrix and Clip.
Use Raster Handle Allocator to blend Skia drawing with custom drawing, typically performed by the host platform user interface. The custom context returned is generated by SkRasterHandleAllocator::MakeCanvas, which creates a custom canvas with raster storage for the drawing destination.
Return Value
context of custom allocation
Example
Example Output
context = skia
See Also
bool peekPixels(SkPixmap* pixmap)
Returns true if Canvas has direct access to its pixels.
Pixels are readable when Device is raster. Pixels are not readable when Canvas is returned from GPU Surface, returned by SkDocument::beginPage, returned by SkPictureRecorder::beginRecording, or Canvas is the base of a utility class like SkDebugCanvas.
pixmap is valid only while Canvas is in scope and unchanged. Any Canvas or Surface call may invalidate the pixmap values.
Parameters
pixmap |
storage for pixel state if pixels are readable; otherwise, ignored |
Return Value
true if Canvas has direct access to pixels
Example
Example Output
width=256 height=256
See Also
readPixels[2][3] SkBitmap::peekPixels SkImage::peekPixels SkSurface::peekPixels
bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY)
Copies Rect of pixels from Canvas into dstPixels. Matrix and Clip are ignored.
Source Rect corners are (srcX, srcY) and (imageInfo().width(), imageInfo().height()). Destination Rect corners are (0, 0) and (dstInfo.width(), dstInfo.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to dstInfo.colorType() and dstInfo.alphaType() if required.
Pixels are readable when Device is raster, or backed by a GPU. Pixels are not readable when SkCanvas is returned by SkDocument::beginPage, returned by SkPictureRecorder::beginRecording, or Canvas is the base of a utility class like SkDebugCanvas.
The destination pixel storage must be allocated by the caller.
Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. dstPixels contents outside Rect intersection are unchanged.
Pass negative values for srcX or srcY to offset pixels across or down destination.
Does not copy, and returns false if:
| Source and destination rectangles do not intersect. |
| Canvas pixels could not be converted to dstInfo.colorType() or dstInfo.alphaType(). |
| Canvas pixels are not readable; for instance, Canvas is document-based. |
| dstRowBytes is too small to contain one row of pixels. |
Parameters
dstInfo |
width, height, Color Type, and Alpha Type of dstPixels |
dstPixels |
storage for pixels; dstInfo.height() times dstRowBytes, or larger |
dstRowBytes |
size of one destination row; dstInfo.width() times pixel size, or larger |
srcX |
offset into readable pixels on x-axis; may be negative |
srcY |
offset into readable pixels on y-axis; may be negative |
Return Value
true if pixels were copied
Example
Example
Example Output
pixel = 802b5580
pixel = 8056a9ff
See Also
peekPixels writePixels[2] drawBitmap drawImage[2] SkBitmap::readPixels[2][3] SkPixmap::readPixels[2][3][4] SkImage::readPixels[2] SkSurface::readPixels[2][3]
bool readPixels(const SkPixmap& pixmap, int srcX, int srcY)
Copies Rect of pixels from Canvas into pixmap. Matrix and Clip are ignored.
Source Rect corners are (srcX, srcY) and (imageInfo().width(), imageInfo().height()). Destination Rect corners are (0, 0) and (pixmap.width(), pixmap.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to pixmap.colorType() and pixmap.alphaType() if required.
Pixels are readable when Device is raster, or backed by a GPU. Pixels are not readable when SkCanvas is returned by SkDocument::beginPage, returned by SkPictureRecorder::beginRecording, or Canvas is the base of a utility class like SkDebugCanvas.
Caller must allocate pixel storage in pixmap if needed.
Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination Rects are copied. pixmap pixels contents outside Rect intersection are unchanged.
Pass negative values for srcX or srcY to offset pixels across or down pixmap.
Does not copy, and returns false if:
| Source and destination rectangles do not intersect. |
| Canvas pixels could not be converted to pixmap.colorType() or pixmap.alphaType(). |
| Canvas pixels are not readable; for instance, Canvas is document-based. |
| Pixmap pixels could not be allocated. |
| pixmap.rowBytes() is too small to contain one row of pixels. |
Parameters
pixmap |
storage for pixels copied from Canvas |
srcX |
offset into readable pixels on x-axis; may be negative |
srcY |
offset into readable pixels on y-axis; may be negative |
Return Value
true if pixels were copied
Example
Example Output
pixel = 802b5580
See Also
peekPixels writePixels[2] drawBitmap drawImage[2] SkBitmap::readPixels[2][3] SkPixmap::readPixels[2][3][4] SkImage::readPixels[2] SkSurface::readPixels[2][3]
bool readPixels(const SkBitmap& bitmap, int srcX, int srcY)
Copies Rect of pixels from Canvas into bitmap. Matrix and Clip are ignored.
Source Rect corners are (srcX, srcY) and (imageInfo().width(), imageInfo().height()). Destination Rect corners are (0, 0) and (bitmap.width(), bitmap.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to bitmap.colorType() and bitmap.alphaType() if required.
Pixels are readable when Device is raster, or backed by a GPU. Pixels are not readable when SkCanvas is returned by SkDocument::beginPage, returned by SkPictureRecorder::beginRecording, or Canvas is the base of a utility class like SkDebugCanvas.
Caller must allocate pixel storage in bitmap if needed.
Bitmap values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. Bitmap pixels outside Rect intersection are unchanged.
Pass negative values for srcX or srcY to offset pixels across or down bitmap.
Does not copy, and returns false if:
| Source and destination rectangles do not intersect. |
| Canvas pixels could not be converted to bitmap.colorType() or bitmap.alphaType(). |
| Canvas pixels are not readable; for instance, Canvas is document-based. |
| bitmap pixels could not be allocated. |
| bitmap.rowBytes() is too small to contain one row of pixels. |
Parameters
bitmap |
storage for pixels copied from Canvas |
srcX |
offset into readable pixels on x-axis; may be negative |
srcY |
offset into readable pixels on y-axis; may be negative |
Return Value
true if pixels were copied
Example
Example Output
pixel = 802b5580
See Also
peekPixels writePixels[2] drawBitmap drawImage[2] SkBitmap::readPixels[2][3] SkPixmap::readPixels[2][3][4] SkImage::readPixels[2] SkSurface::readPixels[2][3]
bool writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y)
Copies Rect from pixels to Canvas. Matrix and Clip are ignored. Source Rect corners are (0, 0) and (info.width(), info.height()). Destination Rect corners are (x, y) and (imageInfo().width(), imageInfo().height()).
Copies each readable pixel intersecting both rectangles, without scaling, converting to imageInfo().colorType() and imageInfo().alphaType() if required.
Pixels are writable when Device is raster, or backed by a GPU. Pixels are not writable when SkCanvas is returned by SkDocument::beginPage, returned by SkPictureRecorder::beginRecording, or Canvas is the base of a utility class like SkDebugCanvas.
Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. Canvas pixels outside Rect intersection are unchanged.
Pass negative values for x or y to offset pixels to the left or above Canvas pixels.
Does not copy, and returns false if:
| Source and destination rectangles do not intersect. |
| pixels could not be converted to Canvas imageInfo().colorType() or imageInfo().alphaType(). |
| Canvas pixels are not writable; for instance, Canvas is document-based. |
| rowBytes is too small to contain one row of pixels. |
Parameters
info |
width, height, Color Type, and Alpha Type of pixels |
pixels |
pixels to copy, of size info.height() times rowBytes, or larger |
rowBytes |
size of one row of pixels; info.width() times pixel size, or larger |
x |
offset into Canvas writable pixels on x-axis; may be negative |
y |
offset into Canvas writable pixels on y-axis; may be negative |
Return Value
true if pixels were written to Canvas
Example
See Also
readPixels[2][3] drawBitmap drawImage[2] SkBitmap::writePixels[2]
bool writePixels(const SkBitmap& bitmap, int x, int y)
Copies Rect from pixels to Canvas. Matrix and Clip are ignored. Source Rect corners are (0, 0) and (bitmap.width(), bitmap.height()).
Destination Rect corners are (x, y) and (imageInfo().width(), imageInfo().height()).
Copies each readable pixel intersecting both rectangles, without scaling, converting to imageInfo().colorType() and imageInfo().alphaType() if required.
Pixels are writable when Device is raster, or backed by a GPU. Pixels are not writable when SkCanvas is returned by SkDocument::beginPage, returned by SkPictureRecorder::beginRecording, or Canvas is the base of a utility class like SkDebugCanvas.
Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. Canvas pixels outside Rect intersection are unchanged.
Pass negative values for x or y to offset pixels to the left or above Canvas pixels.
Does not copy, and returns false if:
| Source and destination rectangles do not intersect. |
| bitmap does not have allocated pixels. |
| bitmap pixels could not be converted to Canvas imageInfo().colorType() or imageInfo().alphaType(). |
| Canvas pixels are not writable; for instance, Canvas is document based. |
| bitmap pixels are inaccessible; for instance, bitmap wraps a texture. |
Parameters
bitmap |
contains pixels copied to Canvas |
x |
offset into Canvas writable pixels in x; may be negative |
y |
offset into Canvas writable pixels in y; may be negative |
Return Value
true if pixels were written to Canvas
Example
See Also
readPixels[2][3] drawBitmap drawImage[2] SkBitmap::writePixels[2]
Canvas maintains a stack of state that allows hierarchical drawing, commonly used to implement windows and views. The initial state has an identity matrix and and an infinite clip. Even with a wide-open clip, drawing is constrained by the bounds of the Canvas Surface or Device.
Canvas savable state consists of Clip and Matrix. Clip describes the area that may be drawn to. Matrix transforms the geometry.
save(), saveLayer, saveLayerPreserveLCDTextRequests, and saveLayerAlpha save state and return the depth of the stack.
restore(), restoreToCount, and ~SkCanvas() revert state to its value when saved.
Each state on the stack intersects Clip with the previous Clip, and concatenates Matrix with the previous Matrix. The intersected Clip makes the drawing area the same or smaller; the concatenated Matrix may move the origin and potentially scale or rotate the coordinate space.
Canvas does not require balancing the state stack but it is a good idea to do so. Calling save() without restore() will eventually cause Skia to fail; mismatched save() and restore() create hard to find bugs.
It is not possible to use state to draw outside of the clip defined by the previous state.
Example
Each Clip uses the current Matrix for its coordinates.
Example
See Also
save saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha restore() restoreToCount
int save()
Saves Matrix and Clip. Calling restore() discards changes to Matrix and Clip, restoring the Matrix and Clip to their state when save() was called.
Matrix may be changed by translate(), scale(), rotate(), skew(), concat(), setMatrix, and resetMatrix. Clip may be changed by clipRect, clipRRect, clipPath, clipRegion.
Saved Canvas state is put on a stack; multiple calls to save() should be balance by an equal number of calls to restore().
Call restoreToCount with result to restore this and subsequent saves.
Return Value
depth of saved stack
Example
See Also
saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha restore restoreToCount
void restore()
Removes changes to Matrix and Clip since Canvas state was last saved. The state is removed from the stack.
Does nothing if the stack is empty.
Example
See Also
save saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha restoreToCount
int getSaveCount() const
Returns the number of saved states, each containing: Matrix and Clip. Equals the number of save() calls less the number of restore() calls plus one. The save count of a new canvas is one.
Return Value
depth of save state stack
Example
Example Output
depth = 1
depth = 2
depth = 1
See Also
void restoreToCount(int saveCount)
Restores state to Matrix and Clip values when save(), saveLayer, saveLayerPreserveLCDTextRequests, or saveLayerAlpha returned saveCount.
Does nothing if saveCount is greater than state stack count. Restores state to initial values if saveCount is less than or equal to one.
Parameters
saveCount |
depth of state stack to restore |
Example
Example Output
depth = 1
depth = 3
depth = 1
See Also
Layer allocates a temporary Bitmap to draw into. When the drawing is complete, the Bitmap is drawn into the Canvas.
Layer is saved in a stack along with other saved state. When state with a Layer is restored, the Bitmap is drawn into the previous Layer.
Layer may be initialized with the contents of the previous Layer. When Layer is restored, its Bitmap can be modified by Paint passed to Layer to apply Color Alpha, Color Filter, Image Filter, and Blend Mode.
int saveLayer(const SkRect* bounds, const SkPaint* paint)
Saves Matrix and Clip, and allocates a Bitmap for subsequent drawing. Calling restore() discards changes to Matrix and Clip, and draws the Bitmap.
Matrix may be changed by translate(), scale(), rotate(), skew(), concat(), setMatrix, and resetMatrix. Clip may be changed by clipRect, clipRRect, clipPath, clipRegion.
Rect bounds suggests but does not define the Bitmap size. To clip drawing to a specific rectangle, use clipRect.
Optional Paint paint applies Color Alpha, Color Filter, Image Filter, and Blend Mode when restore() is called.
Call restoreToCount with returned value to restore this and subsequent saves.
Parameters
bounds |
hint to limit the size of the Layer; may be nullptr |
paint |
graphics state for Layer; may be nullptr |
Return Value
depth of saved stack
Example
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha SaveLayerRec
int saveLayer(const SkRect& bounds, const SkPaint* paint)
Saves Matrix and Clip, and allocates a Bitmap for subsequent drawing. Calling restore() discards changes to Matrix and Clip, and draws the Bitmap.
Matrix may be changed by translate(), scale(), rotate(), skew(), concat(), setMatrix, and resetMatrix. Clip may be changed by clipRect, clipRRect, clipPath, clipRegion.
Rect bounds suggests but does not define the Layer size. To clip drawing to a specific rectangle, use clipRect.
Optional Paint paint applies Color Alpha, Color Filter, Image Filter, and Blend Mode when restore() is called.
Call restoreToCount with returned value to restore this and subsequent saves.
Parameters
bounds |
hint to limit the size of Layer; may be nullptr |
paint |
graphics state for Layer; may be nullptr |
Return Value
depth of saved stack
Example
See Also
save restore saveLayerPreserveLCDTextRequests saveLayerAlpha SaveLayerRec
int saveLayerPreserveLCDTextRequests(const SkRect* bounds, const SkPaint* paint)
Saves Matrix and Clip, and allocates a Bitmap for subsequent drawing. LCD Text is preserved when the Layer is drawn to the prior Layer.
Calling restore() discards changes to Matrix and Clip, and draws Layer.
Matrix may be changed by translate(), scale(), rotate(), skew(), concat(), setMatrix, and resetMatrix. Clip may be changed by clipRect, clipRRect, clipPath, clipRegion.
Rect bounds suggests but does not define the Layer size. To clip drawing to a specific rectangle, use clipRect.
Optional Paint paint applies Color Alpha, Color Filter, Image Filter, and Blend Mode when restore() is called.
Call restoreToCount with returned value to restore this and subsequent saves.
Draw text on an opaque background so that LCD Text blends correctly with the prior Layer. LCD Text drawn on a background with transparency may result in incorrect blending.
Parameters
bounds |
hint to limit the size of Layer; may be nullptr |
paint |
graphics state for Layer; may be nullptr |
Return Value
depth of saved stack
Example
See Also
save restore saveLayer[2][3] saveLayerAlpha SaveLayerRec
int saveLayerAlpha(const SkRect* bounds, U8CPU alpha)
Saves Matrix and Clip, and allocates Bitmap for subsequent drawing.
Calling restore() discards changes to Matrix and Clip, and blends Layer with alpha opacity onto prior Layer.
Matrix may be changed by translate(), scale(), rotate(), skew(), concat(), setMatrix, and resetMatrix. Clip may be changed by clipRect, clipRRect, clipPath, clipRegion.
Rect bounds suggests but does not define Layer size. To clip drawing to a specific rectangle, use clipRect.
alpha of zero is fully transparent, 255 is fully opaque.
Call restoreToCount with returned value to restore this and subsequent saves.
Parameters
bounds |
hint to limit the size of Layer; may be nullptr |
alpha |
opacity of Layer |
Return Value
depth of saved stack
Example
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests SaveLayerRec
enum SaveLayerFlagsSet { kPreserveLCDText_SaveLayerFlag = 1 << 1, kInitWithPrevious_SaveLayerFlag = 1 << 2, kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag = 1 << 3, kDontClipToLayer_Legacy_SaveLayerFlag = kDontClipToLayer_PrivateSaveLayerFlag, };
SaveLayerFlags provides options that may be used in any combination in SaveLayerRec, defining how Layer allocated by saveLayer operates. It may be set to zero, kPreserveLCDText SaveLayerFlag, kInitWithPrevious SaveLayerFlag, or both flags.
Constants
| Const | Value | Description |
|---|---|---|
SkCanvas::kPreserveLCDText_SaveLayerFlag |
2 | Creates Layer for LCD text. Flag is ignored if Layer Paint contains Image Filter or Color Filter. |
SkCanvas::kInitWithPrevious_SaveLayerFlag |
4 | Initializes Layer with the contents of the previous Layer. |
SkCanvas::kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag |
8 | Experimental. Do not use. |
SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag |
0x80000000 | To be deprecated soon. |
Example
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha SaveLayerRec
struct SaveLayerRec { SaveLayerRec(); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, SaveLayerFlags saveLayerFlags); SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, const SkImage* clipMask, const SkMatrix* clipMatrix, SaveLayerFlags saveLayerFlags); const SkRect* fBounds = nullptr; const SkPaint* fPaint = nullptr; const SkImageFilter* fBackdrop = nullptr; const SkImage* fClipMask = nullptr; const SkMatrix* fClipMatrix = nullptr; SaveLayerFlags fSaveLayerFlags = 0; };
SaveLayerRec contains the state used to create the Layer.
| Type | Member | Description |
|---|---|---|
| const SkRect* | fBounds |
fBounds is used as a hint to limit the size of Layer; may be nullptr. fBounds suggests but does not define Layer size. To clip drawing to a specific rectangle, use clipRect. |
| const SkPaint* | fPaint |
fPaint modifies how Layer overlays the prior Layer; may be nullptr. Color Alpha, Blend Mode, Color Filter, Draw Looper, Image Filter, and Mask Filter affect Layer draw. |
| const SkImageFilter* | fBackdrop |
fBackdrop applies Image Filter to the prior Layer when copying to the Layer; may be nullptr. Use kInitWithPrevious SaveLayerFlag to copy the prior Layer without an Image Filter. |
| const SkImage* | fClipMask |
restore() clips Layer by the Color Alpha channel of fClipMask when Layer is copied to Device. fClipMask may be nullptr. . |
| const SkMatrix* | fClipMatrix |
fClipMatrix transforms fClipMask before it clips Layer. If fClipMask describes a translucent gradient, it may be scaled and rotated without introducing artifacts. fClipMatrix may be nullptr. |
| SaveLayerFlags | fSaveLayerFlags |
fSaveLayerFlags are used to create Layer without transparency, create Layer for LCD text, and to create Layer with the contents of the previous Layer. |
Example
SaveLayerRec()
Sets fBounds, fPaint, and fBackdrop to nullptr. Clears fSaveLayerFlags.
Return Value
empty SaveLayerRec
Example
Example Output
rec1 == rec2
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha
SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
Sets fBounds, fPaint, and fSaveLayerFlags; sets fBackdrop to nullptr.
Parameters
bounds |
Layer dimensions; may be nullptr |
paint |
applied to Layer when overlaying prior Layer; may be nullptr |
saveLayerFlags |
SaveLayerRec options to modify Layer |
Return Value
SaveLayerRec with empty backdrop
Example
Example Output
rec1 == rec2
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha
SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, SaveLayerFlags saveLayerFlags)
Sets fBounds, fPaint, fBackdrop, and fSaveLayerFlags.
Parameters
bounds |
Layer dimensions; may be nullptr |
paint |
applied to Layer when overlaying prior Layer; may be nullptr |
backdrop |
prior Layer copied with Image Filter; may be nullptr |
saveLayerFlags |
SaveLayerRec options to modify Layer |
Return Value
SaveLayerRec fully specified
Example
Example Output
rec1 == rec2
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha
SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, const SkImage* clipMask, const SkMatrix* clipMatrix, SaveLayerFlags saveLayerFlags)
Experimental. Not ready for general use.
Sets fBounds, fPaint, fBackdrop, fClipMask, fClipMatrix, and fSaveLayerFlags. clipMatrix uses Color Alpha channel of image, transformed by clipMatrix, to clip Layer when drawn to Canvas.
Implementation is not complete; has no effect if Device is GPU-backed.
Parameters
bounds |
Layer dimensions; may be nullptr |
paint |
graphics state applied to Layer when overlaying prior Layer; may be nullptr |
backdrop |
prior Layer copied with Image Filter; may be nullptr |
clipMask |
clip applied to Layer; may be nullptr |
clipMatrix |
matrix applied to clipMask; may be nullptr to use identity matrix |
saveLayerFlags |
SaveLayerRec options to modify Layer |
Return Value
SaveLayerRec fully specified
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha
int saveLayer(const SaveLayerRec& layerRec)
Saves Matrix and Clip, and allocates Bitmap for subsequent drawing.
Calling restore() discards changes to Matrix and Clip, and blends Bitmap with Color Alpha opacity onto the prior Layer.
Matrix may be changed by translate(), scale(), rotate(), skew(), concat(), setMatrix, and resetMatrix. Clip may be changed by clipRect, clipRRect, clipPath, clipRegion.
SaveLayerRec contains the state used to create the Layer.
Call restoreToCount with returned value to restore this and subsequent saves.
Parameters
layerRec |
Layer state |
Return Value
depth of save state stack
Example
See Also
save restore saveLayer[2][3] saveLayerPreserveLCDTextRequests saveLayerAlpha
void translate(SkScalar dx, SkScalar dy)
Translates Matrix by dx along the x-axis and dy along the y-axis.
Mathematically, replaces Matrix with a translation matrix Premultiplied with Matrix.
This has the effect of moving the drawing by (dx, dy) before transforming the result with Matrix.
Parameters
dx |
distance to translate in x |
dy |
distance to translate in y |
Example
The blue stroke follows translate of (50, 50); a black fill follows scale of (2, 1/2.f). After restoring the clip, which resets Matrix, a red frame follows the same scale of (2, 1/2.f); a gray fill follows translate of (50, 50).
See Also
concat() scale() skew() rotate[2]() setMatrix
void scale(SkScalar sx, SkScalar sy)
Scales Matrix by sx on the x-axis and sy on the y-axis.
Mathematically, replaces Matrix with a scale matrix Premultiplied with Matrix.
This has the effect of scaling the drawing by (sx, sy) before transforming the result with Matrix.
Parameters
sx |
amount to scale in x |
sy |
amount to scale in y |
Example
See Also
concat() translate() skew() rotate[2]() setMatrix
void rotate(SkScalar degrees)
Rotates Matrix by degrees. Positive degrees rotates clockwise.
Mathematically, replaces Matrix with a rotation matrix Premultiplied with Matrix.
This has the effect of rotating the drawing by degrees before transforming the result with Matrix.
Parameters
degrees |
amount to rotate, in degrees |
Example
See Also
concat() translate() skew() scale() setMatrix
void rotate(SkScalar degrees, SkScalar px, SkScalar py)
Rotates Matrix by degrees about a point at (px, py). Positive degrees rotates clockwise.
Mathematically, constructs a rotation matrix; Premultiplies the rotation matrix by a translation matrix; then replaces Matrix with the resulting matrix Premultiplied with Matrix.
This has the effect of rotating the drawing about a given point before transforming the result with Matrix.
Parameters
degrees |
amount to rotate, in degrees |
px |
x-axis value of the point to rotate about |
py |
y-axis value of the point to rotate about |
Example
See Also
concat() translate() skew() scale() setMatrix
void skew(SkScalar sx, SkScalar sy)
Skews Matrix by sx on the x-axis and sy on the y-axis. A positive value of sx skews the drawing right as y-axis values increase; a positive value of sy skews the drawing down as x-axis values increase.
Mathematically, replaces Matrix with a skew matrix Premultiplied with Matrix.
This has the effect of skewing the drawing by (sx, sy) before transforming the result with Matrix.
Parameters
sx |
amount to skew on x-axis |
sy |
amount to skew on y-axis |
Example
See Also
concat() translate() rotate[2]() scale() setMatrix
void concat(const SkMatrix& matrix)
Replaces Matrix with matrix Premultiplied with existing Matrix.
This has the effect of transforming the drawn geometry by matrix, before transforming the result with existing Matrix.
Parameters
matrix |
matrix to Premultiply with existing Matrix |
Example
See Also
translate() rotate[2]() scale() skew() setMatrix
void setMatrix(const SkMatrix& matrix)
Replaces Matrix with matrix. Unlike concat(), any prior matrix state is overwritten.
Parameters
matrix |
matrix to copy, replacing existing Matrix |
Example
See Also
resetMatrix concat() translate() rotate[2]() scale() skew()
void resetMatrix()
Sets Matrix to the identity matrix. Any prior matrix state is overwritten.
Example
See Also
setMatrix concat() translate() rotate[2]() scale() skew()
const SkMatrix& getTotalMatrix() const
Returns Matrix. This does not account for translation by Device or Surface.
Return Value
Example
Example Output
isIdentity true
See Also
setMatrix resetMatrix concat()
Clip is built from a stack of clipping paths. Each Path in the stack can be constructed from one or more Path Contour elements. The Path Contour may be composed of any number of Path Verb segments. Each Path Contour forms a closed area; Path Fill Type defines the area enclosed by Path Contour.
Clip stack of Path elements successfully restrict the Path area. Each Path is transformed by Matrix, then intersected with or subtracted from the prior Clip to form the replacement Clip. Use SkClipOp::kDifference to subtract Path from Clip; use SkClipOp::kIntersect to intersect Path with Clip.
A clipping Path may be Anti Aliased; if Path, after transformation, is composed of horizontal and vertical lines, clearing Anti Alias allows whole pixels to either be inside or outside the clip. The fastest drawing has a Aliased, rectangular clip.
If clipping Path has Anti Alias set, clip may partially clip a pixel, requiring that drawing blend partially with the destination along the edge. A rotated rectangular Anti Aliased clip looks smoother but draws slower.
Clip can combine with Rect and Round Rect primitives; like Path, these are transformed by Matrix before they are combined with Clip.
Clip can combine with Region. Region is assumed to be in Device coordinates and is unaffected by Matrix.
Example
void clipRect(const SkRect& rect, SkClipOp op, bool doAntiAlias)
Replaces Clip with the intersection or difference of Clip and rect, with an Aliased or Anti Aliased clip edge. rect is transformed by Matrix before it is combined with Clip.
Parameters
rect |
Rect to combine with Clip |
op |
Clip Op to apply to Clip |
doAntiAlias |
true if Clip is to be Anti Aliased |
Example
See Also
clipRRect[2][3] clipPath[2][3] clipRegion
void clipRect(const SkRect& rect, SkClipOp op)
Replaces Clip with the intersection or difference of Clip and rect. Resulting Clip is Aliased; pixels are fully contained by the clip. rect is transformed by Matrix before it is combined with Clip.
Parameters
rect |
Rect to combine with Clip |
op |
Clip Op to apply to Clip |
Example
See Also
clipRRect[2][3] clipPath[2][3] clipRegion
void clipRect(const SkRect& rect, bool doAntiAlias = false)
Replaces Clip with the intersection of Clip and rect. Resulting Clip is Aliased; pixels are fully contained by the clip. rect is transformed by Matrix before it is combined with Clip.
Parameters
rect |
Rect to combine with Clip |
doAntiAlias |
true if Clip is to be Anti Aliased |
Example
See Also
clipRRect[2][3] clipPath[2][3] clipRegion
void androidFramework setDeviceClipRestriction(const SkIRect& rect)
Sets the maximum clip rectangle, which can be set by clipRect, clipRRect and clipPath and intersect the current clip with the specified rect. The maximum clip affects only future clipping operations; it is not retroactive. The clip restriction is not recorded in pictures.
Pass an empty rect to disable maximum clip.
Private: This private API is for use by Android framework only.
Parameters
#void clipRRect(const SkRRect& rrect, SkClipOp op, bool doAntiAlias)
Replaces Clip with the intersection or difference of Clip and rrect, with an Aliased or Anti Aliased clip edge. rrect is transformed by Matrix before it is combined with Clip.
Parameters
rect |
maximum allowed clip in device coordinates |
rrect |
Round Rect to combine with Clip |
op |
Clip Op to apply to Clip |
doAntiAlias |
true if Clip is to be Anti Aliased |
Example
See Also
clipRect[2][3] clipPath[2][3] clipRegion
void clipRRect(const SkRRect& rrect, SkClipOp op)
Replaces Clip with the intersection or difference of Clip and rrect. Resulting Clip is Aliased; pixels are fully contained by the clip. rrect is transformed by Matrix before it is combined with Clip.
Parameters
rrect |
Round Rect to combine with Clip |
op |
Clip Op to apply to Clip |
Example
See Also
clipRect[2][3] clipPath[2][3] clipRegion
void clipRRect(const SkRRect& rrect, bool doAntiAlias = false)
Replaces Clip with the intersection of Clip and rrect, with an Aliased or Anti Aliased clip edge. rrect is transformed by Matrix before it is combined with Clip.
Parameters
rrect |
Round Rect to combine with Clip |
doAntiAlias |
true if Clip is to be Anti Aliased |
Example
See Also
clipRect[2][3] clipPath[2][3] clipRegion
void clipPath(const SkPath& path, SkClipOp op, bool doAntiAlias)
Replaces Clip with the intersection or difference of Clip and path, with an Aliased or Anti Aliased clip edge. Path Fill Type determines if path describes the area inside or outside its contours; and if Path Contour overlaps itself or another Path Contour, whether the overlaps form part of the area. path is transformed by Matrix before it is combined with Clip.
Parameters
path |
Path to combine with Clip |
op |
Clip Op to apply to Clip |
doAntiAlias |
true if Clip is to be Anti Aliased |
Example
Bottom figure uses SkPath::kWinding FillType and SkClipOp::kIntersect; area inside clip is intersected with circle.
See Also
clipRect[2][3] clipRRect[2][3] clipRegion
void clipPath(const SkPath& path, SkClipOp op)
Replaces Clip with the intersection or difference of Clip and path. Resulting Clip is Aliased; pixels are fully contained by the clip. Path Fill Type determines if path describes the area inside or outside its contours; and if Path Contour overlaps itself or another Path Contour, whether the overlaps form part of the area. path is transformed by Matrix before it is combined with Clip.
Parameters
path |
Path to combine with Clip |
op |
Clip Op to apply to Clip |
Example
See Also
clipRect[2][3] clipRRect[2][3] clipRegion
void clipPath(const SkPath& path, bool doAntiAlias = false)
Replaces Clip with the intersection of Clip and path. Resulting Clip is Aliased; pixels are fully contained by the clip. Path Fill Type determines if path describes the area inside or outside its contours; and if Path Contour overlaps itself or another Path Contour, whether the overlaps form part of the area. path is transformed by Matrix before it is combined with Clip.
Parameters
path |
Path to combine with Clip |
doAntiAlias |
true if Clip is to be Anti Aliased |
Example
See Also
clipRect[2][3] clipRRect[2][3] clipRegion
void setAllowSimplifyClip(bool allow)
Experimental. For testing only.
Set to simplify clip stack using PathOps.
void clipRegion(const SkRegion& deviceRgn, SkClipOp op = SkClipOp::kIntersect)
Replaces Clip with the intersection or difference of Clip and Region deviceRgn. Resulting Clip is Aliased; pixels are fully contained by the clip. deviceRgn is unaffected by Matrix.
Parameters
deviceRgn |
Region to combine with Clip |
op |
Clip Op to apply to Clip |
Example
See Also
clipRect[2][3] clipRRect[2][3] clipPath[2][3]
bool quickReject(const SkRect& rect) const
Returns true if Rect rect, transformed by Matrix, can be quickly determined to be outside of Clip. May return false even though rect is outside of Clip.
Use to check if an area to be drawn is clipped out, to skip subsequent draw calls.
Parameters
rect |
Rect to compare with Clip |
Return Value
true if rect, transformed by Matrix, does not intersect Clip
Example
Example Output
quickReject true
quickReject false
See Also
getLocalClipBounds[2] getTotalMatrix SkBitmap::drawsNothing
bool quickReject(const SkPath& path) const
Returns true if path, transformed by Matrix, can be quickly determined to be outside of Clip. May return false even though path is outside of Clip.
Use to check if an area to be drawn is clipped out, to skip subsequent draw calls.
Parameters
path |
Path to compare with Clip |
Return Value
true if path, transformed by Matrix, does not intersect Clip
Example
Example Output
quickReject true
quickReject false
See Also
getLocalClipBounds[2] getTotalMatrix SkBitmap::drawsNothing
SkRect getLocalClipBounds() const
Returns bounds of Clip, transformed by inverse of Matrix. If Clip is empty, return SkRect::MakeEmpty, where all Rect sides equal zero.
Rect returned is outset by one to account for partial pixel coverage if Clip is Anti Aliased.
Return Value
bounds of Clip in local coordinates
Example
Example Output
left:-1 top:-1 right:257 bottom:257
left:29 top:129 right:121 bottom:231
left:14.5 top:64.5 right:60.5 bottom:115.5
See Also
getDeviceClipBounds[2] getBaseLayerSize quickReject[2]
bool getLocalClipBounds(SkRect* bounds) const
Returns bounds of Clip, transformed by inverse of Matrix. If Clip is empty, return false, and set bounds to SkRect::MakeEmpty, where all Rect sides equal zero.
bounds is outset by one to account for partial pixel coverage if Clip is Anti Aliased.
Parameters
bounds |
Rect of Clip in local coordinates |
Return Value
true if Clip bounds is not empty
Example
Example Output
local bounds empty = false
local bounds empty = true
See Also
getDeviceClipBounds[2] getBaseLayerSize quickReject[2]
SkIRect getDeviceClipBounds() const
Returns IRect bounds of Clip, unaffected by Matrix. If Clip is empty, return SkRect::MakeEmpty, where all Rect sides equal zero.
Unlike getLocalClipBounds, returned IRect is not outset.
Return Value
bounds of Clip in Device coordinates
Example
Example Output
left:0 top:0 right:256 bottom:256
left:30 top:130 right:120 bottom:230
left:15 top:65 right:60 bottom:115
See Also
getLocalClipBounds[2] getBaseLayerSize quickReject[2]
bool getDeviceClipBounds(SkIRect* bounds) const
Returns IRect bounds of Clip, unaffected by Matrix. If Clip is empty, return false, and set bounds to SkRect::MakeEmpty, where all Rect sides equal zero.
Unlike getLocalClipBounds, bounds is not outset.
Parameters
bounds |
Rect of Clip in device coordinates |
Return Value
true if Clip bounds is not empty
Example
Example Output
device bounds empty = false
device bounds empty = true
See Also
getLocalClipBounds[2] getBaseLayerSize quickReject[2]
void drawColor(SkColor color, SkBlendMode mode = SkBlendMode::kSrcOver)
Fills Clip with Color color. mode determines how ARGB is combined with destination.
Parameters
color |
Unpremultiplied ARGB |
mode |
SkBlendMode used to combine source color and destination |
Example
See Also
clear SkBitmap::erase drawPaint
void clear(SkColor color)
Fills Clip with Color color using SkBlendMode::kSrc. This has the effect of replacing all pixels contained by Clip with color.
Parameters
color |
Unpremultiplied ARGB |
Example
See Also
drawColor SkBitmap::erase drawPaint
void discard()
Makes Canvas contents undefined. Subsequent calls that read Canvas pixels, such as drawing with SkBlendMode, return undefined results. discard() does not change Clip or Matrix.
discard() may do nothing, depending on the implementation of Surface or Device that created Canvas.
discard() allows optimized performance on subsequent draws by removing cached data associated with Surface or Device. It is not necessary to call discard() once done with Canvas; any cached data is deleted when owning Surface or Device is deleted.
See Also
flush() SkSurface::prepareForExternalIO GrContext::abandonContext
void drawPaint(const SkPaint& paint)
Fills Clip with Paint paint. Paint components Mask Filter, Shader, Color Filter, Image Filter, and Blend Mode affect drawing; Path Effect in paint is ignored.
Parameters
paint |
graphics state used to fill Canvas |
Example
See Also
clear drawColor SkBitmap::erase
enum PointMode { kPoints_PointMode, kLines_PointMode, kPolygon_PointMode, };
Selects if an array of points are drawn as discrete points, as lines, or as an open polygon.
Constants
| Const | Value | Description |
|---|---|---|
SkCanvas::kPoints_PointMode |
0 | draw each point separately |
SkCanvas::kLines_PointMode |
1 | draw each pair of points as a line segment |
SkCanvas::kPolygon_PointMode |
2 | draw the array of points as a open polygon |
Example
See Also
drawLine[2] drawPoint[2] drawPath
void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint)
Draws pts using Clip, Matrix and Paint paint. count is the number of points; if count is less than one, has no effect. mode may be one of: kPoints PointMode, kLines PointMode, or kPolygon PointMode.
If mode is kPoints PointMode, the shape of point drawn depends on paint Paint Stroke Cap. If paint is set to SkPaint::kRound Cap, each point draws a circle of diameter Paint Stroke Width. If paint is set to SkPaint::kSquare Cap or SkPaint::kButt Cap, each point draws a square of width and height Paint Stroke Width.
If mode is kLines PointMode, each pair of points draws a line segment. One line is drawn for every two points; each point is used once. If count is odd, the final point is ignored.
If mode is kPolygon PointMode, each adjacent pair of points draws a line segment. count minus one lines are drawn; the first and last point are used once.
Each line segment respects paint Paint Stroke Cap and Paint Stroke Width. Paint Style is ignored, as if were set to SkPaint::kStroke Style.
Always draws each element one at a time; is not affected by Paint Stroke Join, and unlike drawPath, does not create a mask from all points and lines before drawing.
Parameters
mode |
whether pts draws points or lines |
count |
number of points in the array |
pts |
array of points to draw |
paint |
stroke, blend, color, and so on, used to draw |
Example
| The first column draws points. |
| The second column draws points as lines. |
| The third column draws points as a polygon. |
| The fourth column draws points as a polygonal path. |
| The first row uses a round cap and round join. |
| The second row uses a square cap and a miter join. |
| The third row uses a butt cap and a bevel join. |
The transparent color makes multiple line draws visible; the path is drawn all at once.
See Also
drawLine[2] drawPoint[2] drawPath
void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint)
Draws point at (x, y) using Clip, Matrix and Paint paint.
The shape of point drawn depends on paint Paint Stroke Cap. If paint is set to SkPaint::kRound Cap, draw a circle of diameter Paint Stroke Width. If paint is set to SkPaint::kSquare Cap or SkPaint::kButt Cap, draw a square of width and height Paint Stroke Width. Paint Style is ignored, as if were set to SkPaint::kStroke Style.
Parameters
x |
left edge of circle or square |
y |
top edge of circle or square |
paint |
stroke, blend, color, and so on, used to draw |
Example
See Also
drawPoints drawCircle[2] drawRect drawLine[2] drawPath
void drawPoint(SkPoint p, const SkPaint& paint)
Draws point p using Clip, Matrix and Paint paint.
The shape of point drawn depends on paint Paint Stroke Cap. If paint is set to SkPaint::kRound Cap, draw a circle of diameter Paint Stroke Width. If paint is set to SkPaint::kSquare Cap or SkPaint::kButt Cap, draw a square of width and height Paint Stroke Width. Paint Style is ignored, as if were set to SkPaint::kStroke Style.
Parameters
p |
top-left edge of circle or square |
paint |
stroke, blend, color, and so on, used to draw |
Example
See Also
drawPoints drawCircle[2] drawRect drawLine[2] drawPath
void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint)
Draws line segment from (x0, y0) to (x1, y1) using Clip, Matrix, and Paint paint. In paint: Paint Stroke Width describes the line thickness; Paint Stroke Cap draws the end rounded or square; Paint Style is ignored, as if were set to SkPaint::kStroke Style.
Parameters
x0 |
start of line segment on x-axis |
y0 |
start of line segment on y-axis |
x1 |
end of line segment on x-axis |
y1 |
end of line segment on y-axis |
paint |
stroke, blend, color, and so on, used to draw |
Example
See Also
drawPoint[2] drawCircle[2] drawRect drawPath
void drawLine(SkPoint p0, SkPoint p1, const SkPaint& paint)
Draws line segment from p0 to p1 using Clip, Matrix, and Paint paint. In paint: Paint Stroke Width describes the line thickness; Paint Stroke Cap draws the end rounded or square; Paint Style is ignored, as if were set to SkPaint::kStroke Style.
Parameters
p0 |
start of line segment |
p1 |
end of line segment |
paint |
stroke, blend, color, and so on, used to draw |
Example
See Also
drawPoint[2] drawCircle[2] drawRect drawPath
void drawRect(const SkRect& rect, const SkPaint& paint)
Draws Rect rect using Clip, Matrix, and Paint paint. In paint: Paint Style determines if rectangle is stroked or filled; if stroked, Paint Stroke Width describes the line thickness, and Paint Stroke Join draws the corners rounded or square.
Parameters
rect |
rectangle to draw |
paint |
stroke or fill, blend, color, and so on, used to draw |
Example
See Also
drawIRect drawRRect drawRoundRect drawRegion drawPath drawLine[2]
void drawIRect(const SkIRect& rect, const SkPaint& paint)
Draws IRect rect using Clip, Matrix, and Paint paint. In paint: Paint Style determines if rectangle is stroked or filled; if stroked, Paint Stroke Width describes the line thickness, and Paint Stroke Join draws the corners rounded or square.
Parameters
rect |
rectangle to draw |
paint |
stroke or fill, blend, color, and so on, used to draw |
Example
See Also
drawRect drawRRect drawRoundRect drawRegion drawPath drawLine[2]
void drawRegion(const SkRegion& region, const SkPaint& paint)
Draws Region region using Clip, Matrix, and Paint paint. In paint: Paint Style determines if rectangle is stroked or filled; if stroked, Paint Stroke Width describes the line thickness, and Paint Stroke Join draws the corners rounded or square.
Parameters
region |
region to draw |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
See Also
void drawOval(const SkRect& oval, const SkPaint& paint)
Draws Oval oval using Clip, Matrix, and Paint. In paint: Paint Style determines if Oval is stroked or filled; if stroked, Paint Stroke Width describes the line thickness.
Parameters
oval |
Rect bounds of Oval |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
See Also
drawCircle[2] drawPoint[2] drawPath drawRRect drawRoundRect
void drawRRect(const SkRRect& rrect, const SkPaint& paint)
Draws Round Rect rrect using Clip, Matrix, and Paint paint. In paint: Paint Style determines if rrect is stroked or filled; if stroked, Paint Stroke Width describes the line thickness.
rrect may represent a rectangle, circle, oval, uniformly rounded rectangle, or may have any combination of positive non-square radii for the four corners.
Parameters
rrect |
Round Rect with up to eight corner radii to draw |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
See Also
drawRect drawRoundRect drawDRRect drawCircle[2] drawOval drawPath
void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint)
Draws Round Rect outer and inner using Clip, Matrix, and Paint paint. outer must contain inner or the drawing is undefined. In paint: Paint Style determines if Round Rect is stroked or filled; if stroked, Paint Stroke Width describes the line thickness. If stroked and Round Rect corner has zero length radii, Paint Stroke Join can draw corners rounded or square.
GPU-backed platforms optimize drawing when both outer and inner are concave and outer contains inner. These platforms may not be able to draw Path built with identical data as fast.
Parameters
outer |
Round Rect outer bounds to draw |
inner |
Round Rect inner bounds to draw |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
Example
See Also
drawRect drawRoundRect drawRRect drawCircle[2] drawOval drawPath
void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint)
Draws Circle at (cx, cy) with radius using Clip, Matrix, and Paint paint. If radius is zero or less, nothing is drawn. In paint: Paint Style determines if Circle is stroked or filled; if stroked, Paint Stroke Width describes the line thickness.
Parameters
cx |
Circle center on the x-axis |
cy |
Circle center on the y-axis |
radius |
half the diameter of Circle |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
See Also
drawOval drawRRect drawRoundRect drawPath drawArc drawPoint[2] drawLine[2]
void drawCircle(SkPoint center, SkScalar radius, const SkPaint& paint)
Draws Circle at center with radius using Clip, Matrix, and Paint paint. If radius is zero or less, nothing is drawn. In paint: Paint Style determines if Circle is stroked or filled; if stroked, Paint Stroke Width describes the line thickness.
Parameters
center |
Circle center |
radius |
half the diameter of Circle |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
See Also
drawOval drawRRect drawRoundRect drawPath drawArc drawPoint[2] drawLine[2]
void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint)
Draws Arc using Clip, Matrix, and Paint paint.
Arc is part of Oval bounded by oval, sweeping from startAngle to startAngle plus sweepAngle. startAngle and sweepAngle are in degrees.
startAngle of zero places start point at the right middle edge of oval. A positive sweepAngle places Arc end point clockwise from start point; a negative sweepAngle places Arc end point counterclockwise from start point. sweepAngle may exceed 360 degrees, a full circle. If useCenter is true, draw a wedge that includes lines from oval center to Arc end points. If useCenter is false, draw Arc between end points.
If Rect oval is empty or sweepAngle is zero, nothing is drawn.
Parameters
oval |
Rect bounds of Oval containing Arc to draw |
startAngle |
angle in degrees where Arc begins |
sweepAngle |
sweep angle in degrees; positive is clockwise |
useCenter |
if true, include the center of the oval |
paint |
Paint stroke or fill, blend, color, and so on, used to draw |
Example
Example
See Also
SkPath::arcTo[2][3][4][5] drawCircle[2] drawOval drawPath
void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, const SkPaint& paint)
Draws Round Rect bounded by Rect rect, with corner radii (rx, ry) using Clip, Matrix, and Paint paint.
In paint: Paint Style determines if Round Rect is stroked or filled; if stroked, Paint Stroke Width describes the line thickness. If rx or ry are less than zero, they are treated as if they are zero. If rx plus ry exceeds rect width or rect height, radii are scaled down to fit. If rx and ry are zero, Round Rect is drawn as Rect and if stroked is affected by Paint Stroke Join.
Parameters
rect |
Rect bounds of Round Rect to draw |
rx |
axis length on x-axis of oval describing rounded corners |
ry |
axis length on y-axis of oval describing rounded corners |
paint |
stroke, blend, color, and so on, used to draw |
Example
See Also
DrawRRect drawRect drawDRRect drawPath drawCircle[2] drawOval drawPoint[2]
void drawPath(const SkPath& path, const SkPaint& paint)
Draws Path path using Clip, Matrix, and Paint paint. Path contains an array of Path Contour, each of which may be open or closed.
In paint: Paint Style determines if Round Rect is stroked or filled: if filled, Path Fill Type determines whether Path Contour describes inside or outside of fill; if stroked, Paint Stroke Width describes the line thickness, Paint Stroke Cap describes line ends, and Paint Stroke Join describes how corners are drawn.
Parameters
path |
Path to draw |
paint |
stroke, blend, color, and so on, used to draw |
Example
See Also
SkPath drawLine[2] drawArc drawRect drawPoints
drawImage, drawImageRect, and drawImageNine can be called with a bare pointer or a smart pointer as a convenience. The pairs of calls are otherwise identical.
void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr)
Draws Image image, with its top-left corner at (left, top), using Clip, Matrix, and optional Paint paint.
If paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds. If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
Parameters
image |
uncompressed rectangular map of pixels |
left |
left side of image |
top |
top side of image |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawBitmap drawImageLattice drawImageNine[2] drawImageRect[2][3][4][5][6] SkPaint::setImageFilter
void drawImage(const sk sp<SkImage>& image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr)
Draws Image image, with its top-left corner at (left, top), using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds. If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
Parameters
image |
uncompressed rectangular map of pixels |
left |
left side of image |
top |
pop side of image |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawBitmap drawImageLattice drawImageNine[2] drawImageRect[2][3][4][5][6] SkPaint::setImageFilter
enum SrcRectConstraint { kStrict_SrcRectConstraint, kFast_SrcRectConstraint, };
SrcRectConstraint controls the behavior at the edge of source Rect, provided to drawImageRect, trading off speed for precision.
Image Filter in Paint may sample multiple pixels in the image. Source Rect restricts the bounds of pixels that may be read. Image Filter may slow down if it cannot read outside the bounds, when sampling near the edge of source Rect. SrcRectConstraint specifies whether an Image Filter is allowed to read pixels outside source Rect.
Constants
| Const | Value | Description |
|---|---|---|
SkCanvas::kStrict_SrcRectConstraint |
0 | Requires Image Filter to respect source Rect, sampling only inside of its bounds, possibly with a performance penalty. |
SkCanvas::kFast_SrcRectConstraint |
1 | Permits Image Filter to sample outside of source Rect by half the width of Image Filter, permitting it to run faster but with error at the image edges. |
Example
See Also
drawImageRect[2][3][4][5][6] drawImage[2] SkPaint::setImageFilter
void drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws Rect src of Image image, scaled and translated to fill Rect dst. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds.
If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within src; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
image |
Image containing pixels, dimensions, and format |
src |
source Rect of image to draw from |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
filter strictly within src or draw faster |
Example
See Also
SrcRectConstraint drawImage[2] drawImageLattice drawImageNine[2]
void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws IRect isrc of Image image, scaled and translated to fill Rect dst. Note that isrc is on integer pixel boundaries; dst may include fractional boundaries. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds.
If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within isrc; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
image |
Image containing pixels, dimensions, and format |
isrc |
source IRect of image to draw from |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
filter strictly within isrc or draw faster |
Example
See Also
SrcRectConstraint drawImage[2] drawImageLattice drawImageNine[2]
void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint)
Draws Image image, scaled and translated to fill Rect dst, using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds.
If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
Parameters
image |
Image containing pixels, dimensions, and format |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
SrcRectConstraint drawImage[2] drawImageLattice drawImageNine[2]
void drawImageRect(const sk sp<SkImage>& image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws Rect src of Image image, scaled and translated to fill Rect dst. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds.
If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within src; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
image |
Image containing pixels, dimensions, and format |
src |
source Rect of image to draw from |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
filter strictly within src or draw faster |
Example
See Also
SrcRectConstraint drawImage[2] drawImageLattice drawImageNine[2]
void drawImageRect(const sk sp<SkImage>& image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws IRect isrc of Image image, scaled and translated to fill Rect dst. isrc is on integer pixel boundaries; dst may include fractional boundaries. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds.
If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within image; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
image |
Image containing pixels, dimensions, and format |
isrc |
source IRect of image to draw from |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
filter strictly within image or draw faster |
Example
See Also
SrcRectConstraint drawImage[2] drawImageLattice drawImageNine[2]
void drawImageRect(const sk sp<SkImage>& image, const SkRect& dst, const SkPaint* paint)
Draws Image image, scaled and translated to fill Rect dst, using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds.
If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
Parameters
image |
Image containing pixels, dimensions, and format |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
SrcRectConstraint drawImage[2] drawImageLattice drawImageNine[2]
void drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr)
Draws Image image stretched proportionally to fit into Rect dst. IRect center divides the image into nine sections: four sides, four corners, and the center. Corners are unmodified or scaled down proportionately if their sides are larger than dst; center and four sides are scaled to fit remaining space, if any.
Additionally transform draw using Clip, Matrix, and optional Paint paint. If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds. If paint Filter Quality set to kNone_SkFilterQuality, disable pixel filtering. For all other values of paint Filter Quality, use kLow_SkFilterQuality to filter pixels. Any SkMaskFilter on paint is ignored as is paint Anti Aliasing state. If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
Parameters
image |
Image containing pixels, dimensions, and format |
center |
IRect edge of image corners and sides |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawImage[2] drawBitmapNine drawImageLattice drawImageRect[2][3][4][5][6]
void drawImageNine(const sk sp<SkImage>& image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr)
Draws Image image stretched proportionally to fit into Rect dst. IRect center divides the image into nine sections: four sides, four corners, and the center. Corners are not scaled, or scaled down proportionately if their sides are larger than dst; center and four sides are scaled to fit remaining space, if any.
Additionally transform draw using Clip, Matrix, and optional Paint paint. If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds. If paint Filter Quality set to kNone_SkFilterQuality, disable pixel filtering. For all other values of paint Filter Quality, use kLow_SkFilterQuality to filter pixels. Any SkMaskFilter on paint is ignored as is paint Anti Aliasing state. If generated mask extends beyond image bounds, replicate image edge colors, just as Shader made from SkImage::makeShader with SkShader::kClamp TileMode set replicates the image edge color when it samples outside of its bounds.
Parameters
image |
Image containing pixels, dimensions, and format |
center |
IRect edge of image corners and sides |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawImage[2] drawBitmapNine drawImageLattice drawImageRect[2][3][4][5][6]
void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint = nullptr)
Draws Bitmap bitmap, with its top-left corner at (left, top), using Clip, Matrix, and optional Paint paint.
If Paint paint is not nullptr, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If bitmap is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from bitmap bounds.
If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
Parameters
bitmap |
Bitmap containing pixels, dimensions, and format |
left |
left side of bitmap |
top |
top side of bitmap |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawImage[2] drawBitmapLattice drawBitmapNine drawBitmapRect[2][3] SkBitmap::readPixels[2][3] SkBitmap::writePixels[2]
void drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws Rect src of Bitmap bitmap, scaled and translated to fill Rect dst. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If bitmap is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from bitmap bounds.
If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within src; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
bitmap |
Bitmap containing pixels, dimensions, and format |
src |
source Rect of image to draw from |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
filter strictly within src or draw faster |
Example
See Also
drawImageRect[2][3][4][5][6] drawBitmap drawBitmapLattice drawBitmapNine
void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws IRect isrc of Bitmap bitmap, scaled and translated to fill Rect dst. isrc is on integer pixel boundaries; dst may include fractional boundaries. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If bitmap is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from bitmap bounds.
If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within isrc; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
bitmap |
Bitmap containing pixels, dimensions, and format |
isrc |
source IRect of image to draw from |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
sample strictly within isrc, or draw faster |
Example
See Also
drawImageRect[2][3][4][5][6] drawBitmap drawBitmapLattice drawBitmapNine
void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict SrcRectConstraint)
Draws Bitmap bitmap, scaled and translated to fill Rect dst. bitmap bounds is on integer pixel boundaries; dst may include fractional boundaries. Additionally transform draw using Clip, Matrix, and optional Paint paint.
If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If bitmap is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from bitmap bounds.
If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
constraint set to kStrict SrcRectConstraint limits Paint Filter Quality to sample within bitmap; set to kFast SrcRectConstraint allows sampling outside to improve performance.
Parameters
bitmap |
Bitmap containing pixels, dimensions, and format |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
constraint |
filter strictly within bitmap or draw faster |
Example
See Also
drawImageRect[2][3][4][5][6] drawBitmap drawBitmapLattice drawBitmapNine
void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr)
Draws Bitmap bitmap stretched proportionally to fit into Rect dst. IRect center divides the bitmap into nine sections: four sides, four corners, and the center. Corners are not scaled, or scaled down proportionately if their sides are larger than dst; center and four sides are scaled to fit remaining space, if any.
Additionally transform draw using Clip, Matrix, and optional Paint paint. If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If bitmap is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from bitmap bounds. If paint Filter Quality set to kNone_SkFilterQuality, disable pixel filtering. For all other values of paint Filter Quality, use kLow_SkFilterQuality to filter pixels. Any SkMaskFilter on paint is ignored as is paint Anti Aliasing state. If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
Parameters
bitmap |
Bitmap containing pixels, dimensions, and format |
center |
IRect edge of image corners and sides |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawImageNine[2] drawBitmap drawBitmapLattice drawBitmapRect[2][3]
struct Lattice { enum RectType : uint8_t { kDefault = 0, kTransparent, kFixedColor, }; const int* fXDivs; const int* fYDivs; const RectType* fRectTypes; int fXCount; int fYCount; const SkIRect* fBounds; const SkColor* fColors; };
Lattice divides Bitmap or Image into a rectangular grid. Grid entries on even columns and even rows are fixed; these entries are always drawn at their original size if the destination is large enough. If the destination side is too small to hold the fixed entries, all fixed entries are proportionately scaled down to fit. The grid entries not on even columns and rows are scaled to fit the remaining space, if any.
enum RectType : uint8_t { kDefault = 0, kTransparent, kFixedColor, };
Optional setting per rectangular grid entry to make it transparent, or to fill the grid entry with a color.
Constants
| Const | Value | Description |
|---|---|---|
SkCanvas::Lattice::kDefault |
0 | draws Bitmap into lattice rectangle |
SkCanvas::Lattice::kTransparent |
1 | skips lattice rectangle by making it transparent |
SkCanvas::Lattice::kFixedColor |
2 | draws one of fColors into lattice rectangle |
| Type | Member | Description |
|---|---|---|
| const int* | fXDivs |
Array of x-axis values that divide the bitmap vertically. Array entries must be unique, increasing, greater than or equal to fBounds left edge, and less than fBounds right edge. Set the first element to fBounds left to collapse the left column of fixed grid entries. |
| const int* | fYDivs |
Array of y-axis values that divide the bitmap horizontally. Array entries must be unique, increasing, greater than or equal to fBounds top edge, and less than fBounds bottom edge. Set the first element to fBounds top to collapse the top row of fixed grid entries. |
| const RectType* | fRectTypes |
Optional array of fill types, one per rectangular grid entry:
array length must be \(fXCount \+ 1\) \* \(fYCount \+ 1\).
Each RectType is one of: kDefault, kTransparent, kFixedColor. Array entries correspond to the rectangular grid entries, ascending left to right and then top to bottom. |
| int | fXCount |
Number of entries in fXDivs array; one less than the number of horizontal divisions. |
| int | fYCount |
Number of entries in fYDivs array; one less than the number of vertical divisions. |
| const SkIRect* | fBounds |
Optional subset IRect source to draw from. If nullptr, source bounds is dimensions of Bitmap or Image. |
| const SkColor* | fColors |
Optional array of colors, one per rectangular grid entry.
Array length must be \(fXCount \+ 1\) \* \(fYCount \+ 1\).
Array entries correspond to the rectangular grid entries, ascending left to right, then top to bottom. |
void drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr)
Draws Bitmap bitmap stretched proportionally to fit into Rect dst.
Lattice lattice divides bitmap into a rectangular grid. Each intersection of an even-numbered row and column is fixed; like the corners of drawBitmapNine, fixed lattice elements never scale larger than their initial size and shrink proportionately when all fixed elements exceed the bitmap dimension. All other grid elements scale to fill the available space, if any.
Additionally transform draw using Clip, Matrix, and optional Paint paint. If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If bitmap is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from bitmap bounds. If paint Filter Quality set to kNone_SkFilterQuality, disable pixel filtering. For all other values of paint Filter Quality, use kLow_SkFilterQuality to filter pixels. Any SkMaskFilter on paint is ignored as is paint Anti Aliasing state. If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
Parameters
bitmap |
Bitmap containing pixels, dimensions, and format |
lattice |
division of bitmap into fixed and variable rectangles |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawImageLattice drawBitmap drawBitmapNine Lattice
void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr)
Draws Image image stretched proportionally to fit into Rect dst.
Lattice lattice divides image into a rectangular grid. Each intersection of an even-numbered row and column is fixed; like the corners of drawBitmapNine, fixed lattice elements never scale larger than their initial size and shrink proportionately when all fixed elements exceed the bitmap dimension. All other grid elements scale to fill the available space, if any.
Additionally transform draw using Clip, Matrix, and optional Paint paint. If Paint paint is supplied, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper. If image is kAlpha_8_SkColorType, apply Shader. If paint contains Mask Filter, generate mask from image bounds. If paint Filter Quality set to kNone_SkFilterQuality, disable pixel filtering. For all other values of paint Filter Quality, use kLow_SkFilterQuality to filter pixels. Any SkMaskFilter on paint is ignored as is paint Anti Aliasing state. If generated mask extends beyond bitmap bounds, replicate bitmap edge colors, just as Shader made from SkShader::MakeBitmapShader with SkShader::kClamp TileMode set replicates the bitmap edge color when it samples outside of its bounds.
Parameters
image |
Image containing pixels, dimensions, and format |
lattice |
division of bitmap into fixed and variable rectangles |
dst |
destination Rect of image to draw to |
paint |
Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr |
Example
See Also
drawBitmapLattice drawImage[2] drawImageNine[2] Lattice
enum QuadAAFlags : unsigned { kLeft_QuadAAFlag = 0b0001, kTop_QuadAAFlag = 0b0010, kRight_QuadAAFlag = 0b0100, kBottom_QuadAAFlag = 0b1000, kNone_QuadAAFlags = 0b0000, kAll_QuadAAFlags = 0b1111, };
Private: Do not use.
Constants
| Const | Value | Description |
|---|---|---|
SkCanvas::kLeft_QuadAAFlag |
1 | antialias the left edge |
SkCanvas::kTop_QuadAAFlag |
2 | antialias the top edge |
SkCanvas::kRight_QuadAAFlag |
4 | antialias the right edge |
SkCanvas::kBottom_QuadAAFlag |
8 | antialias the bottom edge |
SkCanvas::kNone_QuadAAFlags |
0 | antialias none of the edges |
SkCanvas::kAll_QuadAAFlags |
15 | antialias all of the edges |
struct ImageSetEntry { sk_spSkImage> fImage; SkRect fSrcRect; SkRect fDstRect; unsigned fAAFlags; };
Private: Do not use.
| Type | Member | Description |
|---|---|---|
| SkImage* | fImage |
image to draw |
| SkRect | fSrcRect |
image src rectangle |
| SkRect | fDstRect |
local space rectangle |
| unsigned | fAAFlags |
antialiasing flags |
void experimental DrawImageSetV0(const ImageSetEntry imageSet[], int cnt, float alpha, SkFilterQuality quality, SkBlendMode mode) ;
Private: Do not use.
Draws a set of images. Do not use this method.
Parameters
imageSet |
images |
cnt |
number of images |
alpha |
alpha |
quality |
filter quality |
mode |
blend mode |
void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint)
Draws text, with origin at (x, y), using Clip, Matrix, and Paint paint.
text meaning depends on Paint Text Encoding; by default, text is encoded as UTF-8.
x and y meaning depends on Paint Text Align; by default text draws left to right, positioning the first glyph left side bearing at x and its baseline at y. Text size is affected by Matrix and Paint Text Size.
All elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to text. By default, draws filled 12 point black Glyphs.
Parameters
text |
character code points or Glyphs drawn |
byteLength |
byte length of text array |
x |
start of text on x-axis |
y |
start of text on y-axis |
paint |
text size, blend, color, and so on, used to draw |
Example
See Also
drawString[2] drawPosText drawPosTextH drawTextBlob[2] drawTextRSXform
void drawString(const char* string, SkScalar x, SkScalar y, const SkPaint& paint)
Draws null terminated string, with origin at (x, y), using Clip, Matrix, and Paint paint.
string meaning depends on Paint Text Encoding; by default, strings are encoded as UTF-8. Other values of Paint Text Encoding are unlikely to produce the desired results, since zero bytes may be embedded in the string.
The string draws left to right, positioning the first glyph left side bearing at x and its baseline at y. Text size is affected by Matrix and Paint Text Size.
All elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to text. By default, draws filled 12 point black Glyphs.
Parameters
string |
character code points or Glyphs drawn, ending with a char value of zero |
x |
start of string on x-axis |
y |
start of string on y-axis |
paint |
text size, blend, color, and so on, used to draw |
Example
See Also
drawText drawPosText drawPosTextH drawTextBlob[2] drawTextRSXform
void drawString(const SkString& string, SkScalar x, SkScalar y, const SkPaint& paint)
Draws null terminated string, with origin at (x, y), using Clip, Matrix, and Paint paint.
string meaning depends on Paint Text Encoding; by default, strings are encoded as UTF-8. Other values of Paint Text Encoding are unlikely to produce the desired results, since zero bytes may be embedded in the string.
The string draws left to right, positioning the first glyph left side bearing at x and its baseline at y. Text size is affected by Matrix and Paint Text Size.
All elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to text. By default, draws filled 12 point black Glyphs.
Parameters
string |
character code points or Glyphs drawn, ending with a char value of zero |
x |
start of string on x-axis |
y |
start of string on y-axis |
paint |
text size, blend, color, and so on, used to draw |
Example
See Also
drawText drawPosText drawPosTextH drawTextBlob[2] drawTextRSXform
void drawPosText(const void* text, size_t byteLength, const SkPoint pos[], const SkPaint& paint)
Draws each glyph in text with the origin in pos array, using Clip, Matrix, and Paint paint. The number of entries in pos array must match the number of Glyphs described by byteLength of text.
text meaning depends on Paint Text Encoding; by default, text is encoded as UTF-8. glyph left side bearing and baseline are relative to Point in pos array. Text size is affected by Matrix and Paint Text Size.
All elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to text. By default, draws filled 12 point black Glyphs.
Layout engines such as Harfbuzz typically position each glyph rather than using the font advance widths.
Parameters
text |
character code points or Glyphs drawn |
byteLength |
byte length of text array |
pos |
array of glyph origins |
paint |
text size, blend, color, and so on, used to draw |
Example
See Also
drawText drawPosTextH drawTextBlob[2] drawTextRSXform
void drawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], SkScalar constY, const SkPaint& paint)
Draws each glyph in text with its (x, y) origin composed from xpos array and constY, using Clip, Matrix, and Paint paint. The number of entries in xpos array must match the number of Glyphs described by byteLength of text.
text meaning depends on Paint Text Encoding; by default, text is encoded as UTF-8. Each glyph left side bearing is positioned at an xpos element and its baseline is positioned at constY. Text size is affected by Matrix and Paint Text Size.
All elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to text. By default, draws filled 12 point black Glyphs.
Layout engines such as Harfbuzz typically position each glyph rather than using the font advance widths if all Glyphs share the same baseline.
Parameters
text |
character code points or Glyphs drawn |
byteLength |
byte length of text array |
xpos |
array of x-axis positions, used to position each glyph |
constY |
shared y-axis value for all of x-axis positions |
paint |
text size, blend, color, and so on, used to draw |
Example
See Also
drawText drawPosText drawTextBlob[2] drawTextRSXform
void drawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[], const SkRect* cullRect, const SkPaint& paint)
Draws text, transforming each glyph by the corresponding SkRSXform, using Clip, Matrix, and Paint paint.
RSXform xform array specifies a separate square scale, rotation, and translation for each glyph. xform does not affect paint Shader.
Optional Rect cullRect is a conservative bounds of text, taking into account RSXform and paint. If cullRect is outside of Clip, canvas can skip drawing.
All elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to text. By default, draws filled 12 point black Glyphs.
Parameters
text |
character code points or Glyphs drawn |
byteLength |
byte length of text array |
xform |
RSXform rotates, scales, and translates each glyph individually |
cullRect |
Rect bounds of text for efficient clipping; or nullptr |
paint |
text size, blend, color, and so on, used to draw |
Example
See Also
drawText drawPosText drawTextBlob[2]
void drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint)
Draws Text Blob blob at (x, y), using Clip, Matrix, and Paint paint.
blob contains Glyphs, their positions, and paint attributes specific to text: Typeface, Paint Text Size, Paint Text Scale X, Paint Text Skew X, Paint Text Align, Paint Hinting, Anti Alias, Paint Fake Bold, Font Embedded Bitmaps, Full Hinting Spacing, LCD Text, Linear Text, and Subpixel Text.
Paint Text Encoding must be set to SkPaint::kGlyphID TextEncoding.
Elements of paint: Anti Alias, Blend Mode, Color including Color Alpha, Color Filter, Paint Dither, Draw Looper, Mask Filter, Path Effect, Shader, and Paint Style; apply to blob. If Paint contains SkPaint::kStroke Style: Paint Miter Limit, Paint Stroke Cap, Paint Stroke Join, and Paint Stroke Width; apply to Path created from blob.
Parameters
blob |
Glyphs, positions, and their paints' text size, typeface, and so on |
x |
horizontal offset applied to blob |
y |
vertical offset applied to blob |
paint |
blend, color, stroking, and so on, used to draw |
Example
See Also
drawText drawPosText drawPosTextH
void drawTextBlob(const sk sp<SkTextBlob>& blob, SkScalar x, SkScalar y, const SkPaint& paint)
Draws Text Blob blob at (x, y), using Clip, Matrix, and Paint paint.
blob contains Glyphs, their positions, and paint attributes specific to text: Typeface, Paint Text Size, Paint Text Scale X, Paint Text Skew X, Paint Text Align, Paint Hinting, Anti Alias, Paint Fake Bold, Font Embedded Bitmaps, Full Hinting Spacing, LCD Text, Linear Text, and Subpixel Text.
Paint Text Encoding must be set to SkPaint::kGlyphID TextEncoding.
Elements of paint: Path Effect, Mask Filter, Shader, Color Filter, Image Filter, and Draw Looper; apply to blob.
Parameters
blob |
Glyphs, positions, and their paints' text size, typeface, and so on |
x |
horizontal offset applied to blob |
y |
vertical offset applied to blob |
paint |
blend, color, stroking, and so on, used to draw |
Example
See Also
drawText drawPosText drawPosTextH
void drawPicture(const SkPicture* picture)
Draws Picture picture, using Clip and Matrix. Clip and Matrix are unchanged by picture contents, as if save() was called before and restore() was called after drawPicture.
Picture records a series of draw commands for later playback.
Parameters
picture |
recorded drawing commands to play |
Example
See Also
drawDrawable[2] SkPicture SkPicture::playback
void drawPicture(const sk sp<SkPicture>& picture)
Draws Picture picture, using Clip and Matrix. Clip and Matrix are unchanged by picture contents, as if save() was called before and restore() was called after drawPicture.
Picture records a series of draw commands for later playback.
Parameters
picture |
recorded drawing commands to play |
Example
See Also
drawDrawable[2] SkPicture SkPicture::playback
void drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint)
Draws Picture picture, using Clip and Matrix; transforming picture with Matrix matrix, if provided; and use Paint paint Color Alpha, Color Filter, Image Filter, and Blend Mode, if provided.
matrix transformation is equivalent to: save(), concat(), drawPicture, restore(). paint use is equivalent to: saveLayer, drawPicture, restore().
Parameters
picture |
recorded drawing commands to play |
matrix |
Matrix to rotate, scale, translate, and so on; may be nullptr |
paint |
Paint to apply transparency, filtering, and so on; may be nullptr |
Example
See Also
drawDrawable[2] SkPicture SkPicture::playback
void drawPicture(const sk sp<SkPicture>& picture, const SkMatrix* matrix, const SkPaint* paint)
Draws Picture picture, using Clip and Matrix; transforming picture with Matrix matrix, if provided; and use Paint paint Color Alpha, Color Filter, Image Filter, and Blend Mode, if provided.
matrix transformation is equivalent to: save(), concat(), drawPicture, restore(). paint use is equivalent to: saveLayer, drawPicture, restore().
Parameters
picture |
recorded drawing commands to play |
matrix |
Matrix to rotate, scale, translate, and so on; may be nullptr |
paint |
Paint to apply transparency, filtering, and so on; may be nullptr |
Example
See Also
drawDrawable[2] SkPicture SkPicture::playback
void drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint)
Draws Vertices vertices, a triangle mesh, using Clip and Matrix. If Vertices Texs and Vertices Colors are defined in vertices, and Paint paint contains Shader, Blend Mode mode combines Vertices Colors with Shader.
Parameters
vertices |
triangle mesh to draw |
mode |
combines Vertices Colors with Shader, if both are present |
paint |
specifies the Shader, used as Vertices texture; may be nullptr |
Example
See Also
drawPatch[2] drawPicture[2][3][4]
void drawVertices(const sk sp<SkVertices>& vertices, SkBlendMode mode, const SkPaint& paint)
Draws Vertices vertices, a triangle mesh, using Clip and Matrix. If Vertices Texs and Vertices Colors are defined in vertices, and Paint paint contains Shader, Blend Mode mode combines Vertices Colors with Shader.
Parameters
vertices |
triangle mesh to draw |
mode |
combines Vertices Colors with Shader, if both are present |
paint |
specifies the Shader, used as Vertices texture, may be nullptr |
Example
See Also
drawPatch[2] drawPicture[2][3][4]
void drawVertices(const SkVertices* vertices, const SkVertices::Bone bones[], int boneCount, SkBlendMode mode, const SkPaint& paint)
Draws Vertices vertices, a triangle mesh, using Clip and Matrix. Bone data is used to deform vertices with bone weights. If Vertices Texs and Vertices Colors are defined in vertices, and Paint paint contains Shader, Blend Mode mode combines Vertices Colors with Shader. The first element of bones should be an object to world space transformation matrix that will be applied before performing mesh deformations. If no such transformation is needed, it should be the identity matrix. boneCount must be at most 80, and thus the size of bones should be at most 80.
Parameters
vertices |
triangle mesh to draw |
bones |
bone matrix data |
boneCount |
number of bone matrices |
mode |
combines Vertices Colors with Shader, if both are present |
paint |
specifies the Shader, used as Vertices texture, may be nullptr |
See Also
drawPatch[2] drawPicture[2][3][4]
void drawVertices(const sk sp<SkVertices>& vertices, const SkVertices::Bone bones[], int boneCount, SkBlendMode mode, const SkPaint& paint)
Draws Vertices vertices, a triangle mesh, using Clip and Matrix. Bone data is used to deform vertices with bone weights. If Vertices Texs and Vertices Colors are defined in vertices, and Paint paint contains Shader, Blend Mode mode combines Vertices Colors with Shader. The first element of bones should be an object to world space transformation matrix that will be applied before performing mesh deformations. If no such transformation is needed, it should be the identity matrix. boneCount must be at most 80, and thus the size of bones should be at most 80.
Parameters
vertices |
triangle mesh to draw |
bones |
bone matrix data |
boneCount |
number of bone matrices |
mode |
combines Vertices Colors with Shader, if both are present |
paint |
specifies the Shader, used as Vertices texture, may be nullptr |
See Also
drawPatch[2] drawPicture[2][3][4]
void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint)
Draws a Coons Patch: the interpolation of four cubics with shared corners, associating a color, and optionally a texture Point, with each corner.
Coons Patch uses Clip and Matrix, paint Shader, Color Filter, Color Alpha, Image Filter, and Blend Mode. If Shader is provided it is treated as Coons Patch texture; Blend Mode mode combines Color colors and Shader if both are provided.
Point array cubics specifies four Cubics starting at the top-left corner, in clockwise order, sharing every fourth point. The last Cubic ends at the first point.
Color array color associates colors with corners in top-left, top-right, bottom-right, bottom-left order.
If paint contains Shader, Point array texCoords maps Shader as texture to corners in top-left, top-right, bottom-right, bottom-left order.
Parameters
#cubics |
Path Cubic array, sharing common points |
colors |
Color array, one for each corner |
texCoords |
Point array of texture coordinates, mapping Shader to corners; may be nullptr |
mode |
Blend Mode for colors, and for Shader if paint has one |
paint |
Shader, Color Filter, Blend Mode, used to draw |
Example
See Also
SeeAlso drawVertices[2][3][4] drawPicture[2][3][4]
void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], const SkPaint& paint)
Draws Cubic Coons Patch: the interpolation of four cubics with shared corners, associating a color, and optionally a texture Point, with each corner.
Coons Patch uses Clip and Matrix, paint Shader, Color Filter, Color Alpha, Image Filter, and Blend Mode. If Shader is provided it is treated as Coons Patch texture; Blend Mode mode combines Color colors and Shader if both are provided.
Point array cubics specifies four Cubics starting at the top-left corner, in clockwise order, sharing every fourth point. The last Cubic ends at the first point.
Color array color associates colors with corners in top-left, top-right, bottom-right, bottom-left order.
If paint contains Shader, Point array texCoords maps Shader as texture to corners in top-left, top-right, bottom-right, bottom-left order.
Parameters
#cubics |
Path Cubic array, sharing common points |
colors |
Color array, one for each corner |
texCoords |
Point array of texture coordinates, mapping Shader to corners; may be nullptr |
paint |
Shader, Color Filter, Blend Mode, used to draw |
Example
Example
See Also
SeeAlso drawVertices[2][3][4] drawPicture[2][3][4]
void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint)
Draws a set of sprites from atlas, using Clip, Matrix, and optional Paint paint. paint uses Anti Alias, Color Alpha, Color Filter, Image Filter, and Blend Mode to draw, if present. For each entry in the array, Rect tex locates sprite in atlas, and RSXform xform transforms it into destination space.
xform, text, and colors if present, must contain count entries. Optional colors are applied for each sprite using Blend Mode mode, treating sprite as source and colors as destination. Optional cullRect is a conservative bounds of all transformed sprites. If cullRect is outside of Clip, canvas can skip drawing.
Parameters
atlas |
Image containing sprites |
xform |
RSXform mappings for sprites in atlas |
tex |
Rect locations of sprites in atlas |
colors |
one per sprite, blended with sprite using Blend Mode; may be nullptr |
count |
number of sprites to draw |
mode |
Blend Mode combining colors and sprites |
cullRect |
bounds of transformed sprites for efficient clipping; may be nullptr |
paint |
Color Filter, Image Filter, Blend Mode, and so on; may be nullptr |
Example
See Also
void drawAtlas(const sk sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint)
Draws a set of sprites from atlas, using Clip, Matrix, and optional Paint paint. paint uses Anti Alias, Color Alpha, Color Filter, Image Filter, and Blend Mode to draw, if present. For each entry in the array, Rect tex locates sprite in atlas, and RSXform xform transforms it into destination space.
xform, text, and colors if present, must contain count entries. Optional colors is applied for each sprite using Blend Mode. Optional cullRect is a conservative bounds of all transformed sprites. If cullRect is outside of Clip, canvas can skip drawing.
Parameters
atlas |
Image containing sprites |
xform |
RSXform mappings for sprites in atlas |
tex |
Rect locations of sprites in atlas |
colors |
one per sprite, blended with sprite using Blend Mode; may be nullptr |
count |
number of sprites to draw |
mode |
Blend Mode combining colors and sprites |
cullRect |
bounds of transformed sprites for efficient clipping; may be nullptr |
paint |
Color Filter, Image Filter, Blend Mode, and so on; may be nullptr |
Example
See Also
void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint)
Draws a set of sprites from atlas, using Clip, Matrix, and optional Paint paint. paint uses Anti Alias, Color Alpha, Color Filter, Image Filter, and Blend Mode to draw, if present. For each entry in the array, Rect tex locates sprite in atlas, and RSXform xform transforms it into destination space.
xform and text must contain count entries. Optional cullRect is a conservative bounds of all transformed sprites. If cullRect is outside of Clip, canvas can skip drawing.
Parameters
atlas |
Image containing sprites |
xform |
RSXform mappings for sprites in atlas |
tex |
Rect locations of sprites in atlas |
count |
number of sprites to draw |
cullRect |
bounds of transformed sprites for efficient clipping; may be nullptr |
paint |
Color Filter, Image Filter, Blend Mode, and so on; may be nullptr |
Example
See Also
void drawAtlas(const sk sp<SkImage>& atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint)
Draws a set of sprites from atlas, using Clip, Matrix, and optional Paint paint. paint uses Anti Alias, Color Alpha, Color Filter, Image Filter, and Blend Mode to draw, if present. For each entry in the array, Rect tex locates sprite in atlas, and RSXform xform transforms it into destination space.
xform and text must contain count entries. Optional cullRect is a conservative bounds of all transformed sprites. If cullRect is outside of Clip, canvas can skip drawing.
Parameters
atlas |
Image containing sprites |
xform |
RSXform mappings for sprites in atlas |
tex |
Rect locations of sprites in atlas |
count |
number of sprites to draw |
cullRect |
bounds of transformed sprites for efficient clipping; may be nullptr |
paint |
Color Filter, Image Filter, Blend Mode, and so on; may be nullptr |
Example
See Also
void drawDrawable(SkDrawable* drawable, const SkMatrix* matrix = nullptr)
Draws Drawable drawable using Clip and Matrix, concatenated with optional matrix.
If Canvas has an asynchronous implementation, as is the case when it is recording into Picture, then drawable will be referenced, so that SkDrawable::draw() can be called when the operation is finalized. To force immediate drawing, call SkDrawable::draw() instead.
Parameters
drawable |
custom struct encapsulating drawing commands |
matrix |
transformation applied to drawing; may be nullptr |
Example
See Also
SkDrawable drawPicture[2][3][4]
void drawDrawable(SkDrawable* drawable, SkScalar x, SkScalar y)
Draws Drawable drawable using Clip and Matrix, offset by (x, y).
If Canvas has an asynchronous implementation, as is the case when it is recording into Picture, then drawable will be referenced, so that SkDrawable::draw() can be called when the operation is finalized. To force immediate drawing, call SkDrawable::draw() instead.
Parameters
drawable |
custom struct encapsulating drawing commands |
x |
offset into Canvas writable pixels on x-axis |
y |
offset into Canvas writable pixels on y-axis |
Example
See Also
SkDrawable drawPicture[2][3][4]
void drawAnnotation(const SkRect& rect, const char key[], SkData* value)
Associates Rect on Canvas with an annotation; a key-value pair, where the key is a null-terminated utf8 string, and optional value is stored as Data.
Only some canvas implementations, such as recording to Picture, or drawing to Document PDF, use annotations.
Parameters
rect |
Rect extent of canvas to annotate |
key |
string used for lookup |
value |
data holding value stored in annotation |
Example
See Also
void drawAnnotation(const SkRect& rect, const char key[], const sk sp<SkData>& value)
Associates Rect on Canvas when an annotation; a key-value pair, where the key is a null-terminated utf8 string, and optional value is stored as Data.
Only some canvas implementations, such as recording to Picture, or drawing to Document PDF, use annotations.
Parameters
rect |
Rect extent of canvas to annotate |
key |
string used for lookup |
value |
data holding value stored in annotation |
Example
See Also
virtual bool isClipEmpty() const
Returns true if Clip is empty; that is, nothing will draw.
May do work when called; it should not be called more often than needed. However, once called, subsequent calls perform no work until Clip changes.
Return Value
true if Clip is empty
Example
Example Output
clip is not empty
clip is empty
See Also
isClipRect getLocalClipBounds[2] getDeviceClipBounds[2]
virtual bool isClipRect() const
Returns true if Clip is Rect and not empty. Returns false if the clip is empty, or if it is not Rect.
Return Value
true if Clip is Rect and not empty
Example
Example Output
clip is rect
clip is not rect