#Topic Canvas #Alias Canvas_Reference ## #Class SkCanvas #Code #Populate ## 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. Canvas may be created directly when no Surface is required; some Canvas methods implicitly create Raster_Surface. # ------------------------------------------------------------------------------ #Method static std::unique_ptr MakeRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes, const SkSurfaceProps* props = nullptr) #In Constructors #Line # creates from SkImageInfo and Pixel_Storage ## #Populate #Example #Description Allocates a three by three bitmap, clears it to white, and draws a black pixel in the center. ## void draw(SkCanvas* ) { SkImageInfo info = SkImageInfo::MakeN32Premul(3, 3); // device aligned, 32 bpp, Premultiplied const size_t minRowBytes = info.minRowBytes(); // bytes used by one bitmap row const size_t size = info.computeMinByteSize(); // bytes used by all rows SkAutoTMalloc storage(size); // allocate storage for pixels SkPMColor* pixels = storage.get(); // get pointer to allocated storage // create a SkCanvas backed by a raster device, and delete it when the // function goes out of scope. std::unique_ptr canvas = SkCanvas::MakeRasterDirect(info, pixels, minRowBytes); canvas->clear(SK_ColorWHITE); // white is Unpremultiplied, in ARGB order canvas->flush(); // ensure that pixels are cleared SkPMColor pmWhite = pixels[0]; // the Premultiplied format may vary SkPaint paint; // by default, draws black canvas->drawPoint(1, 1, paint); // draw in the center canvas->flush(); // ensure that point was drawn for (int y = 0; y < info.height(); ++y) { for (int x = 0; x < info.width(); ++x) { SkDebugf("%c", *pixels++ == pmWhite ? '-' : 'x'); } SkDebugf("\n"); } } #StdOut --- -x- --- ## ## #SeeAlso MakeRasterDirectN32 SkSurface::MakeRasterDirect ## # ------------------------------------------------------------------------------ #Method static std::unique_ptr MakeRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes) #In Constructors #Line # creates from image data and Pixel_Storage ## #Populate #Example #Description Allocates a three by three bitmap, clears it to white, and draws a black pixel in the center. ## void draw(SkCanvas* ) { const int width = 3; const int height = 3; SkPMColor pixels[height][width]; // allocate a 3 by 3 Premultiplied bitmap on the stack // create a SkCanvas backed by a raster device, and delete it when the // function goes out of scope. std::unique_ptr canvas = SkCanvas::MakeRasterDirectN32( width, height, pixels[0], // top-left of the bitmap sizeof(pixels[0])); // byte width of the each row // write a Premultiplied value for white into all pixels in the bitmap canvas->clear(SK_ColorWHITE); SkPMColor pmWhite = pixels[0][0]; // the Premultiplied format may vary SkPaint paint; // by default, draws black canvas->drawPoint(1, 1, paint); // draw in the center canvas->flush(); // ensure that pixels is ready to be read for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { SkDebugf("%c", pixels[y][x] == pmWhite ? '-' : 'x'); } SkDebugf("\n"); } } #StdOut --- -x- --- ## ## #SeeAlso MakeRasterDirect SkSurface::MakeRasterDirect SkImageInfo::MakeN32Premul ## # ------------------------------------------------------------------------------ #Method SkCanvas() #Line # creates with no Surface, no dimensions ## #Populate #Example #Description Passes a placeholder to a function that requires one. ## #Function static void check_for_rotated_ctm(const SkCanvas* canvas) { const SkMatrix& matrix = canvas->getTotalMatrix(); SkDebugf("rect stays rect is %s\n", matrix.rectStaysRect() ? "true" : "false"); } ## void draw(SkCanvas* canvas) { check_for_rotated_ctm(canvas); canvas->rotate(30); check_for_rotated_ctm(canvas); SkCanvas defaultCanvas; check_for_rotated_ctm(&defaultCanvas); } #StdOut rect stays rect is true rect stays rect is false rect stays rect is true ## ## #SeeAlso MakeRasterDirect SkRasterHandleAllocator::MakeCanvas SkSurface::getCanvas SkCreateColorSpaceXformCanvas ## # ------------------------------------------------------------------------------ #Method SkCanvas(int width, int height, const SkSurfaceProps* props = nullptr) #Line # creates with no Surface, set dimensions, Surface_Properties ## #Populate #Example SkCanvas canvas(10, 20); // 10 units wide, 20 units high canvas.clipRect(SkRect::MakeXYWH(30, 40, 5, 10)); // clip is outside canvas' device SkDebugf("canvas %s empty\n", canvas.getDeviceClipBounds().isEmpty() ? "is" : "is not"); #StdOut canvas is empty ## ## #SeeAlso MakeRasterDirect SkSurfaceProps SkPixelGeometry SkCreateColorSpaceXformCanvas ## # ------------------------------------------------------------------------------ #Method explicit SkCanvas(const SkBitmap& bitmap) #Line # uses existing Bitmap ## #Populate #Example #Description The actual output depends on the installed fonts. ## SkBitmap bitmap; // create a bitmap 5 wide and 11 high bitmap.allocPixels(SkImageInfo::MakeN32Premul(5, 11)); SkCanvas canvas(bitmap); canvas.clear(SK_ColorWHITE); // white is Unpremultiplied, in ARGB order SkPixmap pixmap; // provides guaranteed access to the drawn pixels if (!canvas.peekPixels(&pixmap)) { SkDebugf("peekPixels should never fail.\n"); } const SkPMColor* pixels = pixmap.addr32(); // points to top-left of bitmap SkPMColor pmWhite = pixels[0]; // the Premultiplied format may vary SkPaint paint; // by default, draws black, 12 point text canvas.drawString("!", 1, 10, SkFont(), paint); // 1 char at baseline (1, 10) for (int y = 0; y < bitmap.height(); ++y) { for (int x = 0; x < bitmap.width(); ++x) { SkDebugf("%c", *pixels++ == pmWhite ? '-' : 'x'); } SkDebugf("\n"); } ## #SeeAlso MakeRasterDirect SkRasterHandleAllocator::MakeCanvas SkSurface::getCanvas SkCreateColorSpaceXformCanvas ## # ------------------------------------------------------------------------------ #Method SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props) #Line # uses existing Bitmap and Surface_Properties ## #Populate #Example #Description The actual output depends on the installed fonts. ## SkBitmap bitmap; // create a bitmap 5 wide and 11 high bitmap.allocPixels(SkImageInfo::MakeN32Premul(5, 11)); SkCanvas canvas(bitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry)); canvas.clear(SK_ColorWHITE); // white is Unpremultiplied, in ARGB order SkPixmap pixmap; // provides guaranteed access to the drawn pixels if (!canvas.peekPixels(&pixmap)) { SkDebugf("peekPixels should never fail.\n"); } const SkPMColor* pixels = pixmap.addr32(); // points to top-left of bitmap SkPMColor pmWhite = pixels[0]; // the Premultiplied format may vary SkPaint paint; // by default, draws black, 12 point text canvas.drawString("!", 1, 10, SkFont(), paint); // 1 char at baseline (1, 10) for (int y = 0; y < bitmap.height(); ++y) { for (int x = 0; x < bitmap.width(); ++x) { SkDebugf("%c", *pixels++ == pmWhite ? '-' : 'x'); } SkDebugf("\n"); } ## #SeeAlso MakeRasterDirect SkRasterHandleAllocator::MakeCanvas SkSurface::getCanvas SkCreateColorSpaceXformCanvas ## # ------------------------------------------------------------------------------ #Method virtual ~SkCanvas() #Line # draws saved Layers, frees resources ## #Populate #Example #Description Canvas Layer draws into bitmap. saveLayerAlpha sets up an additional drawing surface that blends with the bitmap. When Layer goes out of scope, Layer destructor is called. The saved Layer is restored, drawing transparent letters. ## void draw(SkCanvas* canvas) { SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(200, 200)); { SkCanvas offscreen(bitmap); SkPaint paint; SkFont font(nullptr, 100); offscreen.drawString("ABC", 20, 160, font, paint); SkRect layerBounds = SkRect::MakeXYWH(32, 32, 192, 192); offscreen.saveLayerAlpha(&layerBounds, 128); offscreen.clear(SK_ColorWHITE); offscreen.drawString("DEF", 20, 160, font, paint); } canvas->drawBitmap(bitmap, 0, 0, nullptr); } ## #SeeAlso State_Stack ## # ------------------------------------------------------------------------------ #Subtopic Property #Line # metrics and attributes ## ## #Method SkImageInfo imageInfo() const #In Property #Line # returns Image_Info for Canvas ## #Populate #Example SkCanvas emptyCanvas; SkImageInfo canvasInfo = emptyCanvas.imageInfo(); SkImageInfo emptyInfo; SkDebugf("emptyInfo %c= canvasInfo\n", emptyInfo == canvasInfo ? '=' : '!'); #StdOut emptyInfo == canvasInfo ## ## #SeeAlso SkImageInfo MakeRasterDirect makeSurface ## # ------------------------------------------------------------------------------ #Method bool getProps(SkSurfaceProps* props) const #In Property #Line # copies Surface_Properties if available ## #Populate #Example SkBitmap bitmap; SkCanvas canvas(bitmap, SkSurfaceProps(0, kRGB_V_SkPixelGeometry)); SkSurfaceProps surfaceProps(0, kUnknown_SkPixelGeometry); SkDebugf("isRGB:%d\n", SkPixelGeometryIsRGB(surfaceProps.pixelGeometry())); if (!canvas.getProps(&surfaceProps)) { SkDebugf("getProps failed unexpectedly.\n"); } SkDebugf("isRGB:%d\n", SkPixelGeometryIsRGB(surfaceProps.pixelGeometry())); #StdOut isRGB:0 isRGB:1 #StdOut ## ## #SeeAlso SkSurfaceProps makeSurface ## # ------------------------------------------------------------------------------ #Subtopic Utility #Line # rarely called management functions ## ## #Method void flush() #In Utility #Line # triggers execution of all pending draw operations ## #Populate #NoExample ## #SeeAlso peekPixels SkSurface::flush GrContext::flush GrContext::abandonContext ## # ------------------------------------------------------------------------------ #Method virtual SkISize getBaseLayerSize() const #In Property #Line # returns size of base Layer in global coordinates ## #Populate #Example SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(20, 30)); SkCanvas canvas(bitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry)); canvas.clipRect(SkRect::MakeWH(10, 40)); SkIRect clipDeviceBounds = canvas.getDeviceClipBounds(); if (clipDeviceBounds.isEmpty()) { SkDebugf("Empty clip bounds is unexpected!\n"); } SkDebugf("clip=%d,%d\n", clipDeviceBounds.width(), clipDeviceBounds.height()); SkISize baseLayerSize = canvas.getBaseLayerSize(); SkDebugf("size=%d,%d\n", baseLayerSize.width(), baseLayerSize.height()); #StdOut clip=10,30 size=20,30 ## ## #ToDo is this the same as the width and height of surface? ## #SeeAlso getDeviceClipBounds ## # ------------------------------------------------------------------------------ #Method sk_sp makeSurface(const SkImageInfo& info, const SkSurfaceProps* props = nullptr) #In Constructors #Line # creates Surface matching SkImageInfo and SkSurfaceProps ## #Populate #Example sk_sp surface = SkSurface::MakeRasterN32Premul(5, 6); SkCanvas* smallCanvas = surface->getCanvas(); SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(3, 4); sk_sp compatible = smallCanvas->makeSurface(imageInfo); SkDebugf("compatible %c= nullptr\n", compatible == nullptr ? '=' : '!'); SkDebugf("size = %d, %d\n", compatible->width(), compatible->height()); #StdOut compatible != nullptr size = 3, 4 ## ## #SeeAlso SkSurface SkSurface::makeSurface SkImageInfo SkSurfaceProps ## # ------------------------------------------------------------------------------ #Method virtual GrContext* getGrContext() #In Property #Line # returns GPU_Context of the GPU_Surface ## #Populate #Example void draw(SkCanvas* canvas) { if (canvas->getGrContext()) { canvas->clear(SK_ColorRED); } else { canvas->clear(SK_ColorBLUE); } } ## #ToDo fiddle should show both CPU and GPU out ## #SeeAlso GrContext ## # ------------------------------------------------------------------------------ #Method void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin = nullptr) #In Utility #In Property #Line # returns writable pixel access if available ## #Populate #Example void draw(SkCanvas* canvas) { if (canvas->accessTopLayerPixels(nullptr, nullptr)) { canvas->clear(SK_ColorRED); } else { canvas->clear(SK_ColorBLUE); } } ## #Example #Description Draws "ABC" on the device. Then draws "DEF" in Layer, and reads Layer to add a large dotted "DEF". Finally blends Layer with the device. The Layer and blended result appear on the CPU and GPU but the large dotted "DEF" appear only on the CPU. ## void draw(SkCanvas* canvas) { SkPaint paint; SkFont font(nullptr, 100); canvas->drawString("ABC", 20, 160, font, paint); SkRect layerBounds = SkRect::MakeXYWH(32, 32, 192, 192); canvas->saveLayerAlpha(&layerBounds, 128); canvas->clear(SK_ColorWHITE); canvas->drawString("DEF", 20, 160, font, paint); SkImageInfo imageInfo; size_t rowBytes; SkIPoint origin; uint32_t* access = (uint32_t*) canvas->accessTopLayerPixels(&imageInfo, &rowBytes, &origin); if (access) { int h = imageInfo.height(); int v = imageInfo.width(); int rowWords = rowBytes / sizeof(uint32_t); for (int y = 0; y < h; ++y) { int newY = (y - h / 2) * 2 + h / 2; if (newY < 0 || newY >= h) { continue; } for (int x = 0; x < v; ++x) { int newX = (x - v / 2) * 2 + v / 2; if (newX < 0 || newX >= v) { continue; } if (access[y * rowWords + x] == SK_ColorBLACK) { access[newY * rowWords + newX] = SK_ColorGRAY; } } } } canvas->restore(); } ## #ToDo there are no callers of this that I can find. Deprecate? ## #ToDo fiddle should show both CPU and GPU out ## #SeeAlso SkImageInfo SkPixmap ## # ------------------------------------------------------------------------------ #Method SkRasterHandleAllocator::Handle accessTopRasterHandle() const #In Utility #In Property #Line # returns context that tracks Clip and Matrix ## #Populate #Example #Description #ToDo ## ## #Function static void DeleteCallback(void*, void* context) { delete (char*) context; } class CustomAllocator : public SkRasterHandleAllocator { public: bool allocHandle(const SkImageInfo& info, Rec* rec) override { char* context = new char[4]{'s', 'k', 'i', 'a'}; rec->fReleaseProc = DeleteCallback; rec->fReleaseCtx = context; rec->fHandle = context; rec->fPixels = context; rec->fRowBytes = 4; return true; } void updateHandle(Handle handle, const SkMatrix& ctm, const SkIRect& clip_bounds) override { // apply canvas matrix and clip to custom environment } }; ## void draw(SkCanvas* canvas) { const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1); std::unique_ptr c2 = SkRasterHandleAllocator::MakeCanvas(std::unique_ptr( new CustomAllocator()), info); char* context = (char*) c2->accessTopRasterHandle(); SkDebugf("context = %.4s\n", context); } #StdOut context = skia ## #ToDo skstd::make_unique could not be used because def is private -- note to fix in c++14? ## ## #SeeAlso SkRasterHandleAllocator ## # ------------------------------------------------------------------------------ #Subtopic Pixels #Line # read and write pixel values ## ## #Method bool peekPixels(SkPixmap* pixmap) #In Pixels #Line # returns if Canvas has direct access to its pixels ## #Populate #Example SkPixmap pixmap; if (canvas->peekPixels(&pixmap)) { SkDebugf("width=%d height=%d\n", pixmap.bounds().width(), pixmap.bounds().height()); } #StdOut width=256 height=256 ## ## #SeeAlso readPixels SkBitmap::peekPixels SkImage::peekPixels SkSurface::peekPixels ## # ------------------------------------------------------------------------------ #Method bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY) #In Pixels #Line # copies and converts rectangle of pixels from Canvas ## 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: #List # 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. ## ## #Param dstInfo width, height, Color_Type, and Alpha_Type of dstPixels ## #Param dstPixels storage for pixels; dstInfo.height() times dstRowBytes, or larger ## #Param dstRowBytes size of one destination row; dstInfo.width() times pixel size, or larger ## #Param srcX offset into readable pixels on x-axis; may be negative ## #Param srcY offset into readable pixels on y-axis; may be negative ## #Return true if pixels were copied ## #Example #Width 64 #Height 64 #Description A black circle drawn on a blue background provides an image to copy. readPixels copies one quarter of the canvas into each of the four corners. The copied quarter circles overdraw the original circle. ## canvas->clear(SK_ColorBLUE); SkPaint paint; canvas->drawCircle(32, 32, 28, paint); SkImageInfo info = SkImageInfo::Make(64, 64, kBGRA_8888_SkColorType, kPremul_SkAlphaType); sk_sp data(SkData::MakeUninitialized(info.minRowBytes() * info.height())); sk_bzero(data->writable_data(), info.minRowBytes() * info.height()); for (int x : { 32, -32 } ) { for (int y : { 32, -32 } ) { canvas->readPixels(info, data->writable_data(), info.minRowBytes(), x, y); } } sk_sp image = SkImage::MakeRasterData(info, data, info.minRowBytes()); canvas->drawImage(image, 0, 0); ## #Example #Description Canvas returned by Raster_Surface has Premultiplied pixel values. clear() takes Unpremultiplied input with Color_Alpha equal 0x80 and RGB equal 0x55, 0xAA, 0xFF. RGB is multiplied by Color_Alpha to generate Premultiplied value 0x802B5580. readPixels converts pixel back to Unpremultiplied value 0x8056A9FF, introducing error. ## canvas->clear(0x8055aaff); for (SkAlphaType alphaType : { kPremul_SkAlphaType, kUnpremul_SkAlphaType } ) { uint32_t pixel = 0; SkImageInfo info = SkImageInfo::Make(1, 1, kBGRA_8888_SkColorType, alphaType); if (canvas->readPixels(info, &pixel, 4, 0, 0)) { SkDebugf("pixel = %08x\n", pixel); } } #StdOut pixel = 802b5580 pixel = 8056a9ff ## ## #SeeAlso peekPixels writePixels drawBitmap drawImage SkBitmap::readPixels SkPixmap::readPixels SkImage::readPixels SkSurface::readPixels ## # ------------------------------------------------------------------------------ #Method 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: #List # 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. ## ## #Param pixmap storage for pixels copied from Canvas ## #Param srcX offset into readable pixels on x-axis; may be negative ## #Param srcY offset into readable pixels on y-axis; may be negative ## #Return true if pixels were copied ## #Example #Description clear() takes Unpremultiplied input with Color_Alpha equal 0x80 and RGB equal 0x55, 0xAA, 0xFF. RGB is multiplied by Color_Alpha to generate Premultiplied value 0x802B5580. ## void draw(SkCanvas* canvas) { canvas->clear(0x8055aaff); uint32_t pixels[1] = { 0 }; SkPixmap pixmap(SkImageInfo::MakeN32Premul(1, 1), pixels, 4); canvas->readPixels(pixmap, 0, 0); SkDebugf("pixel = %08x\n", pixels[0]); } #StdOut pixel = 802b5580 ## ## #SeeAlso peekPixels writePixels drawBitmap drawImage SkBitmap::readPixels SkPixmap::readPixels SkImage::readPixels SkSurface::readPixels ## # ------------------------------------------------------------------------------ #Method 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: #List # 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. ## ## #Param bitmap storage for pixels copied from Canvas ## #Param srcX offset into readable pixels on x-axis; may be negative ## #Param srcY offset into readable pixels on y-axis; may be negative ## #Return true if pixels were copied ## #Example #Description clear() takes Unpremultiplied input with Color_Alpha equal 0x80 and RGB equal 0x55, 0xAA, 0xFF. RGB is multiplied by Color_Alpha to generate Premultiplied value 0x802B5580. ## void draw(SkCanvas* canvas) { canvas->clear(0x8055aaff); SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(1, 1)); canvas->readPixels(bitmap, 0, 0); SkDebugf("pixel = %08x\n", bitmap.getAddr32(0, 0)[0]); } #StdOut pixel = 802b5580 ## ## #SeeAlso peekPixels writePixels drawBitmap drawImage SkBitmap::readPixels SkPixmap::readPixels SkImage::readPixels SkSurface::readPixels ## # ------------------------------------------------------------------------------ #Method bool writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y) #In Pixels #Line # copies and converts rectangle of pixels to Canvas ## 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: #List # 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. ## ## #Param info width, height, Color_Type, and Alpha_Type of pixels ## #Param pixels pixels to copy, of size info.height() times rowBytes, or larger ## #Param rowBytes size of one row of pixels; info.width() times pixel size, or larger ## #Param x offset into Canvas writable pixels on x-axis; may be negative ## #Param y offset into Canvas writable pixels on y-axis; may be negative ## #Return true if pixels were written to Canvas ## #Example SkImageInfo imageInfo = SkImageInfo::MakeN32(256, 1, kPremul_SkAlphaType); for (int y = 0; y < 256; ++y) { uint32_t pixels[256]; for (int x = 0; x < 256; ++x) { pixels[x] = SkColorSetARGB(x, x + y, x, x - y); } canvas->writePixels(imageInfo, &pixels, sizeof(pixels), 0, y); } ## #SeeAlso readPixels drawBitmap drawImage SkBitmap::writePixels ## # ------------------------------------------------------------------------------ #Method 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: #List # 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. ## ## #Param bitmap contains pixels copied to Canvas ## #Param x offset into Canvas writable pixels in x; may be negative ## #Param y offset into Canvas writable pixels in y; may be negative ## #Return true if pixels were written to Canvas ## #Example void draw(SkCanvas* canvas) { SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(2, 2); SkBitmap bitmap; bitmap.setInfo(imageInfo); uint32_t pixels[4]; bitmap.setPixels(pixels); for (int y = 0; y < 256; y += 2) { for (int x = 0; x < 256; x += 2) { pixels[0] = SkColorSetRGB(x, y, x | y); pixels[1] = SkColorSetRGB(x ^ y, y, x); pixels[2] = SkColorSetRGB(x, x & y, y); pixels[3] = SkColorSetRGB(~x, ~y, x); canvas->writePixels(bitmap, x, y); } } } ## #SeeAlso readPixels drawBitmap drawImage SkBitmap::writePixels ## # ------------------------------------------------------------------------------ #Subtopic State_Stack #Line # stack of state for hierarchical drawing ## 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, 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 #Description Draw to ever smaller clips; then restore drawing to full canvas. Note that the second clipRect is not permitted to enlarge Clip. ## #Height 160 void draw(SkCanvas* canvas) { SkPaint paint; canvas->save(); // records stack depth to restore canvas->clipRect(SkRect::MakeWH(100, 100)); // constrains drawing to clip canvas->clear(SK_ColorRED); // draws to limit of clip canvas->save(); // records stack depth to restore canvas->clipRect(SkRect::MakeWH(50, 150)); // Rect below 100 is ignored canvas->clear(SK_ColorBLUE); // draws to smaller clip canvas->restore(); // enlarges clip canvas->drawLine(20, 20, 150, 150, paint); // line below 100 is not drawn canvas->restore(); // enlarges clip canvas->drawLine(150, 20, 50, 120, paint); // line below 100 is drawn } ## Each Clip uses the current Matrix for its coordinates. #Example #Description While clipRect is given the same rectangle twice, Matrix makes the second clipRect draw at half the size of the first. ## #Height 128 void draw(SkCanvas* canvas) { canvas->clipRect(SkRect::MakeWH(100, 100)); canvas->clear(SK_ColorRED); canvas->scale(.5, .5); canvas->clipRect(SkRect::MakeWH(100, 100)); canvas->clear(SK_ColorBLUE); } ## #SeeAlso save saveLayer saveLayerAlpha restore() restoreToCount #Method int save() #In State_Stack #Line # saves Clip and Matrix on stack ## #Populate #Example #Description The black square is translated 50 pixels down and to the right. Restoring Canvas state removes translate() from Canvas stack; the red square is not translated, and is drawn at the origin. ## #Height 100 void draw(SkCanvas* canvas) { SkPaint paint; SkRect rect = { 0, 0, 25, 25 }; canvas->drawRect(rect, paint); canvas->save(); canvas->translate(50, 50); canvas->drawRect(rect, paint); canvas->restore(); paint.setColor(SK_ColorRED); canvas->drawRect(rect, paint); } ## #SeeAlso saveLayer saveLayerAlpha restore restoreToCount ## # ------------------------------------------------------------------------------ #Method void restore() #In State_Stack #Line # restores changes to Clip and Matrix, pops save stack ## #Populate #Example void draw(SkCanvas* canvas) { SkCanvas simple; SkDebugf("depth = %d\n", simple.getSaveCount()); simple.restore(); SkDebugf("depth = %d\n", simple.getSaveCount()); } ## #SeeAlso save saveLayer saveLayerAlpha restoreToCount ## # ------------------------------------------------------------------------------ #Method int getSaveCount() const #In State_Stack #Line # returns depth of stack containing Clip and Matrix ## #Populate #Example void draw(SkCanvas* canvas) { SkCanvas simple; SkDebugf("depth = %d\n", simple.getSaveCount()); simple.save(); SkDebugf("depth = %d\n", simple.getSaveCount()); simple.restore(); SkDebugf("depth = %d\n", simple.getSaveCount()); } #StdOut depth = 1 depth = 2 depth = 1 ## ## #SeeAlso save restore restoreToCount ## # ------------------------------------------------------------------------------ #Method void restoreToCount(int saveCount) #In State_Stack #Line # restores changes to Clip and Matrix to given depth ## #Populate #Example void draw(SkCanvas* canvas) { SkDebugf("depth = %d\n", canvas->getSaveCount()); canvas->save(); canvas->save(); SkDebugf("depth = %d\n", canvas->getSaveCount()); canvas->restoreToCount(0); SkDebugf("depth = %d\n", canvas->getSaveCount()); } #StdOut depth = 1 depth = 3 depth = 1 ## ## #SeeAlso restore getSaveCount save ## #Subtopic State_Stack ## # ------------------------------------------------------------------------------ #Subtopic Layer #Substitute layer #Alias Layers #Substitute layers ## #Line # temporary Bitmap to draw into ## 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. #Method int saveLayer(const SkRect* bounds, const SkPaint* paint) #In Layer #Line # saves Clip and Matrix on stack; creates Layer ## #Populate #Example #Description Rectangles are blurred by Image_Filter when restore() draws Layer to main Canvas. ## #Height 128 #Function ###$ #include "SkBlurImageFilter.h" $$$# ## void draw(SkCanvas* canvas) { SkPaint paint, blur; blur.setImageFilter(SkBlurImageFilter::Make(3, 3, nullptr)); canvas->saveLayer(nullptr, &blur); SkRect rect = { 25, 25, 50, 50}; canvas->drawRect(rect, paint); canvas->translate(50, 50); paint.setColor(SK_ColorRED); canvas->drawRect(rect, paint); canvas->restore(); } ## #SeeAlso save restore saveLayer saveLayerAlpha SaveLayerRec ## #Method int saveLayer(const SkRect& bounds, const SkPaint* paint) #In Layer #Populate #Example #Description Rectangles are blurred by Image_Filter when restore() draws Layer to main Canvas. The red rectangle is clipped; it does not fully fit on Layer. Image_Filter blurs past edge of Layer so red rectangle is blurred on all sides. ## #Height 128 #Function ###$ #include "SkBlurImageFilter.h" $$$# ## void draw(SkCanvas* canvas) { SkPaint paint, blur; blur.setImageFilter(SkBlurImageFilter::Make(3, 3, nullptr)); canvas->saveLayer(SkRect::MakeWH(90, 90), &blur); SkRect rect = { 25, 25, 50, 50}; canvas->drawRect(rect, paint); canvas->translate(50, 50); paint.setColor(SK_ColorRED); canvas->drawRect(rect, paint); canvas->restore(); } ## #SeeAlso save restore saveLayerAlpha SaveLayerRec ## #Method int saveLayerAlpha(const SkRect* bounds, U8CPU alpha) #In Layer #Line # saves Clip and Matrix on stack; creates Layer; sets opacity ## #Populate #Example SkPaint paint; paint.setColor(SK_ColorRED); canvas->drawCircle(50, 50, 50, paint); canvas->saveLayerAlpha(nullptr, 128); paint.setColor(SK_ColorBLUE); canvas->drawCircle(100, 50, 50, paint); paint.setColor(SK_ColorGREEN); paint.setAlpha(128); canvas->drawCircle(75, 90, 50, paint); canvas->restore(); ## #SeeAlso save restore saveLayer SaveLayerRec ## #Enum SaveLayerFlagsSet #Line # sets SaveLayerRec options ## #Code #Populate ## #Typedef uint32_t SaveLayerFlags #Line # options for SaveLayerRec ## ## 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 or kInitWithPrevious_SaveLayerFlag. #Const kInitWithPrevious_SaveLayerFlag 4 #Line # initializes with previous contents ## Initializes Layer with the contents of the previous Layer. ## #Example #Height 160 #Description Canvas Layer captures red and blue circles scaled up by four. scalePaint blends Layer back with transparency. ## void draw(SkCanvas* canvas) { SkPaint redPaint, bluePaint, scalePaint; redPaint.setColor(SK_ColorRED); canvas->drawCircle(21, 21, 8, redPaint); bluePaint.setColor(SK_ColorBLUE); canvas->drawCircle(31, 21, 8, bluePaint); SkMatrix matrix; matrix.setScale(4, 4); scalePaint.setAlpha(0x40); scalePaint.setImageFilter( SkImageFilter::MakeMatrixFilter(matrix, kNone_SkFilterQuality, nullptr)); SkCanvas::SaveLayerRec saveLayerRec(nullptr, &scalePaint, SkCanvas::kInitWithPrevious_SaveLayerFlag); canvas->saveLayer(saveLayerRec); canvas->restore(); } ## #SeeAlso save restore saveLayer saveLayerAlpha SaveLayerRec #Enum ## #Subtopic SaveLayerRec #Line # contains the state used to create the Layer ## #Struct SaveLayerRec #Line # contains the state used to create the Layer ## #Code #Populate ## SaveLayerRec contains the state used to create the Layer. #Member const SkRect* fBounds #Line # hints at Layer size limit ## 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. ## #Member const SkPaint* fPaint #Line # modifies overlay ## 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. ## #Member const SkImageFilter* fBackdrop #Line # applies Image_Filter to prior Layer ## 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. ## #Member const SkImage* fClipMask #Line # clips Layer with Mask_Alpha ## restore() clips Layer by the Color_Alpha channel of fClipMask when Layer is copied to Device. fClipMask may be nullptr. . ## #Member const SkMatrix* fClipMatrix #Line # transforms Mask_Alpha used to clip ## 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. ## #Member SaveLayerFlags fSaveLayerFlags #Line # creates with prior Layer contents ## fSaveLayerFlags are used to create Layer without transparency, and to create Layer with the contents of the previous Layer. ## #Example #Height 160 #Description Canvas Layer captures a red Anti_Aliased circle and a blue Aliased circle scaled up by four. After drawing another red circle without scaling on top, the Layer is transferred to the main canvas. ## void draw(SkCanvas* canvas) { SkPaint redPaint, bluePaint; redPaint.setAntiAlias(true); redPaint.setColor(SK_ColorRED); canvas->drawCircle(21, 21, 8, redPaint); bluePaint.setColor(SK_ColorBLUE); canvas->drawCircle(31, 21, 8, bluePaint); SkMatrix matrix; matrix.setScale(4, 4); auto scaler = SkImageFilter::MakeMatrixFilter(matrix, kNone_SkFilterQuality, nullptr); SkCanvas::SaveLayerRec saveLayerRec(nullptr, nullptr, scaler.get(), 0); canvas->saveLayer(saveLayerRec); canvas->drawCircle(125, 85, 8, redPaint); canvas->restore(); } ## #Subtopic Constructors ## #Method SaveLayerRec() #Line # constructs SaveLayerRec ## #Populate #Example SkCanvas::SaveLayerRec rec1; rec1.fSaveLayerFlags = SkCanvas::kInitWithPrevious_SaveLayerFlag; SkCanvas::SaveLayerRec rec2(nullptr, nullptr, SkCanvas::kInitWithPrevious_SaveLayerFlag); SkDebugf("rec1 %c= rec2\n", rec1.fBounds == rec2.fBounds && rec1.fPaint == rec2.fPaint && rec1.fBackdrop == rec2.fBackdrop && rec1.fSaveLayerFlags == rec2.fSaveLayerFlags ? '=' : '!'); #StdOut rec1 == rec2 ## ## #SeeAlso save restore saveLayer saveLayerAlpha ## #Method SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0) #Populate #Example SkCanvas::SaveLayerRec rec1; SkCanvas::SaveLayerRec rec2(nullptr, nullptr); SkDebugf("rec1 %c= rec2\n", rec1.fBounds == rec2.fBounds && rec1.fPaint == rec2.fPaint && rec1.fBackdrop == rec2.fBackdrop && rec1.fSaveLayerFlags == rec2.fSaveLayerFlags ? '=' : '!'); #StdOut rec1 == rec2 ## ## #SeeAlso save restore saveLayer saveLayerAlpha ## #Method SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop, SaveLayerFlags saveLayerFlags) #Populate #Example SkCanvas::SaveLayerRec rec1; SkCanvas::SaveLayerRec rec2(nullptr, nullptr, nullptr, 0); SkDebugf("rec1 %c= rec2\n", rec1.fBounds == rec2.fBounds && rec1.fPaint == rec2.fPaint && rec1.fBackdrop == rec2.fBackdrop && rec1.fSaveLayerFlags == rec2.fSaveLayerFlags ? '=' : '!'); #StdOut rec1 == rec2 ## ## #SeeAlso save restore saveLayer saveLayerAlpha ## #Struct ## #Subtopic ## #Method int saveLayer(const SaveLayerRec& layerRec) #In Layer #Populate #Example #Description The example draws an image, and saves it into a Layer with kInitWithPrevious_SaveLayerFlag. Next it punches a hole in Layer and restore with SkBlendMode::kPlus. Where Layer was cleared, the original image will draw unchanged. Outside of the circle the mandrill is brightened. ## #Image 3 // sk_sp image = GetResourceAsImage("images/mandrill_256.png"); canvas->drawImage(image, 0, 0, nullptr); SkCanvas::SaveLayerRec rec; SkPaint paint; paint.setBlendMode(SkBlendMode::kPlus); rec.fSaveLayerFlags = SkCanvas::kInitWithPrevious_SaveLayerFlag; rec.fPaint = &paint; canvas->saveLayer(rec); paint.setBlendMode(SkBlendMode::kClear); canvas->drawCircle(128, 128, 96, paint); canvas->restore(); ## #ToDo above example needs to replace GetResourceAsImage with way to select image in fiddle ## #SeeAlso save restore saveLayer saveLayerAlpha ## #Subtopic Layer ## # ------------------------------------------------------------------------------ #Subtopic Matrix #Line # coordinate transformation ## #Method void translate(SkScalar dx, SkScalar dy) #In Matrix #Line # translates Matrix ## #Populate #Example #Height 128 #Description scale() followed by translate() produces different results from translate() followed by scale(). 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). ## void draw(SkCanvas* canvas) { SkPaint filledPaint; SkPaint outlinePaint; outlinePaint.setStyle(SkPaint::kStroke_Style); outlinePaint.setColor(SK_ColorBLUE); canvas->save(); canvas->translate(50, 50); canvas->drawCircle(28, 28, 15, outlinePaint); // blue center: (50+28, 50+28) canvas->scale(2, 1/2.f); canvas->drawCircle(28, 28, 15, filledPaint); // black center: (50+(28*2), 50+(28/2)) canvas->restore(); filledPaint.setColor(SK_ColorGRAY); outlinePaint.setColor(SK_ColorRED); canvas->scale(2, 1/2.f); canvas->drawCircle(28, 28, 15, outlinePaint); // red center: (28*2, 28/2) canvas->translate(50, 50); canvas->drawCircle(28, 28, 15, filledPaint); // gray center: ((50+28)*2, (50+28)/2) } ## #SeeAlso concat() scale() skew() rotate() setMatrix ## # ------------------------------------------------------------------------------ #Method void scale(SkScalar sx, SkScalar sy) #In Matrix #Line # scales Matrix ## #Populate #Example #Height 160 void draw(SkCanvas* canvas) { SkPaint paint; SkRect rect = { 10, 20, 60, 120 }; canvas->translate(20, 20); canvas->drawRect(rect, paint); canvas->scale(2, .5f); paint.setColor(SK_ColorGRAY); canvas->drawRect(rect, paint); } ## #SeeAlso concat() translate() skew() rotate() setMatrix ## # ------------------------------------------------------------------------------ #Method void rotate(SkScalar degrees) #In Matrix #Line # rotates Matrix ## #Populate #Example #Description Draw clock hands at time 5:10. The hour hand and minute hand point up and are rotated clockwise. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); canvas->translate(128, 128); canvas->drawCircle(0, 0, 60, paint); canvas->save(); canvas->rotate(10 * 360 / 60); // 10 minutes of 60 scaled to 360 degrees canvas->drawLine(0, 0, 0, -50, paint); canvas->restore(); canvas->rotate((5 + 10.f/60) * 360 / 12); // 5 and 10/60 hours of 12 scaled to 360 degrees canvas->drawLine(0, 0, 0, -30, paint); } ## #SeeAlso concat() translate() skew() scale() setMatrix ## # ------------------------------------------------------------------------------ #Method void rotate(SkScalar degrees, SkScalar px, SkScalar py) #In Matrix #Populate #Example #Height 192 void draw(SkCanvas* canvas) { SkPaint paint; SkFont font(nullptr, 96); canvas->drawString("A1", 130, 100, font, paint); canvas->rotate(180, 130, 100); canvas->drawString("A1", 130, 100, font, paint); } ## #SeeAlso concat() translate() skew() scale() setMatrix ## # ------------------------------------------------------------------------------ #Method void skew(SkScalar sx, SkScalar sy) #In Matrix #Line # skews Matrix ## #Populate #Example #Description Black text mimics an oblique text style by using a negative skew on x-axis that shifts the geometry to the right as the y-axis values decrease. Red text uses a positive skew on y-axis to shift the geometry down as the x-axis values increase. Blue text combines sx and sy skew to rotate and scale. ## SkPaint paint; SkFont font(nullptr, 128); canvas->translate(30, 130); canvas->save(); canvas->skew(-.5, 0); canvas->drawString("A1", 0, 0, font, paint); canvas->restore(); canvas->save(); canvas->skew(0, .5); paint.setColor(SK_ColorRED); canvas->drawString("A1", 0, 0, font, paint); canvas->restore(); canvas->skew(-.5, .5); paint.setColor(SK_ColorBLUE); canvas->drawString("A1", 0, 0, font, paint); ## #SeeAlso concat() translate() rotate() scale() setMatrix ## # ------------------------------------------------------------------------------ #Method void concat(const SkMatrix& matrix) #In Matrix #Line # multiplies Matrix by Matrix ## #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; SkFont font(nullptr, 80); font.setScaleX(.3); SkMatrix matrix; SkRect rect[2] = {{ 10, 20, 90, 110 }, { 40, 130, 140, 180 }}; matrix.setRectToRect(rect[0], rect[1], SkMatrix::kFill_ScaleToFit); canvas->drawRect(rect[0], paint); canvas->drawRect(rect[1], paint); paint.setColor(SK_ColorWHITE); canvas->drawString("Here", rect[0].fLeft + 10, rect[0].fBottom - 10, font, paint); canvas->concat(matrix); canvas->drawString("There", rect[0].fLeft + 10, rect[0].fBottom - 10, font, paint); } ## #SeeAlso translate() rotate() scale() skew() setMatrix ## # ------------------------------------------------------------------------------ #Method void setMatrix(const SkMatrix& matrix) #In Matrix #Line # sets Matrix ## #Populate #Example #Height 128 void draw(SkCanvas* canvas) { SkPaint paint; SkFont font; canvas->scale(4, 6); canvas->drawString("truth", 2, 10, font, paint); SkMatrix matrix; matrix.setScale(2.8f, 6); canvas->setMatrix(matrix); canvas->drawString("consequences", 2, 20, font, paint); } ## #SeeAlso resetMatrix concat() translate() rotate() scale() skew() ## # ------------------------------------------------------------------------------ #Method void resetMatrix() #In Matrix #Line # resets Matrix to identity ## #Populate #Example #Height 128 void draw(SkCanvas* canvas) { SkPaint paint; SkFont font; canvas->scale(4, 6); canvas->drawString("truth", 2, 10, font, paint); canvas->resetMatrix(); canvas->scale(2.8f, 6); canvas->drawString("consequences", 2, 20, font, paint); } ## #SeeAlso setMatrix concat() translate() rotate() scale() skew() ## # ------------------------------------------------------------------------------ #Method const SkMatrix& getTotalMatrix() const #In Matrix #Line # returns Matrix ## #Populate #Example SkDebugf("isIdentity %s\n", canvas->getTotalMatrix().isIdentity() ? "true" : "false"); #StdOut isIdentity true ## ## #SeeAlso setMatrix resetMatrix concat() ## #Subtopic Matrix ## # ------------------------------------------------------------------------------ #Subtopic Clip #Line # stack of clipping Paths ## 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 #Height 90 #Description Draw a red circle with an Aliased clip and an Anti_Aliased clip. Use an image filter to zoom into the pixels drawn. The edge of the Aliased clip fully draws pixels in the red circle. The edge of the Anti_Aliased clip partially draws pixels in the red circle. ## SkPaint redPaint, scalePaint; redPaint.setAntiAlias(true); redPaint.setColor(SK_ColorRED); canvas->save(); for (bool antialias : { false, true } ) { canvas->save(); canvas->clipRect(SkRect::MakeWH(19.5f, 11.5f), antialias); canvas->drawCircle(17, 11, 8, redPaint); canvas->restore(); canvas->translate(16, 0); } canvas->restore(); SkMatrix matrix; matrix.setScale(6, 6); scalePaint.setImageFilter( SkImageFilter::MakeMatrixFilter(matrix, kNone_SkFilterQuality, nullptr)); SkCanvas::SaveLayerRec saveLayerRec( nullptr, &scalePaint, SkCanvas::kInitWithPrevious_SaveLayerFlag); canvas->saveLayer(saveLayerRec); canvas->restore(); ## #Method void clipRect(const SkRect& rect, SkClipOp op, bool doAntiAlias) #In Clip #Line # combines Clip with Rect ## #Populate #Example #Height 128 void draw(SkCanvas* canvas) { canvas->rotate(10); SkPaint paint; paint.setAntiAlias(true); for (auto alias: { false, true } ) { canvas->save(); canvas->clipRect(SkRect::MakeWH(90, 80), SkClipOp::kIntersect, alias); canvas->drawCircle(100, 60, 60, paint); canvas->restore(); canvas->translate(80, 0); } } ## #SeeAlso clipRRect clipPath clipRegion ## #Method void clipRect(const SkRect& rect, SkClipOp op) #In Clip #Populate #Example #Height 192 #Width 280 void draw(SkCanvas* canvas) { SkPaint paint; for (SkClipOp op: { SkClipOp::kIntersect, SkClipOp::kDifference } ) { canvas->save(); canvas->clipRect(SkRect::MakeWH(90, 120), op, false); canvas->drawCircle(100, 100, 60, paint); canvas->restore(); canvas->translate(80, 0); } } ## #SeeAlso clipRRect clipPath clipRegion ## #Method void clipRect(const SkRect& rect, bool doAntiAlias = false) #In Clip #Populate #Example #Height 133 #Description A circle drawn in pieces looks uniform when drawn Aliased. The same circle pieces blend with pixels more than once when Anti_Aliased, visible as a thin pair of lines through the right circle. ## void draw(SkCanvas* canvas) { canvas->clear(SK_ColorWHITE); SkPaint paint; paint.setAntiAlias(true); paint.setColor(0x8055aaff); SkRect clipRect = { 0, 0, 87.4f, 87.4f }; for (auto alias: { false, true } ) { canvas->save(); canvas->clipRect(clipRect, SkClipOp::kIntersect, alias); canvas->drawCircle(67, 67, 60, paint); canvas->restore(); canvas->save(); canvas->clipRect(clipRect, SkClipOp::kDifference, alias); canvas->drawCircle(67, 67, 60, paint); canvas->restore(); canvas->translate(120, 0); } } ## #SeeAlso clipRRect clipPath clipRegion ## #Method void clipRRect(const SkRRect& rrect, SkClipOp op, bool doAntiAlias) #In Clip #Line # combines Clip with Round_Rect ## #Populate #Example #Height 128 void draw(SkCanvas* canvas) { canvas->clear(SK_ColorWHITE); SkPaint paint; paint.setAntiAlias(true); paint.setColor(0x8055aaff); SkRRect oval; oval.setOval({10, 20, 90, 100}); canvas->clipRRect(oval, SkClipOp::kIntersect, true); canvas->drawCircle(70, 100, 60, paint); } ## #SeeAlso clipRect clipPath clipRegion ## #Method void clipRRect(const SkRRect& rrect, SkClipOp op) #In Clip #Populate #Example #Height 128 void draw(SkCanvas* canvas) { SkPaint paint; paint.setColor(0x8055aaff); auto oval = SkRRect::MakeOval({10, 20, 90, 100}); canvas->clipRRect(oval, SkClipOp::kIntersect); canvas->drawCircle(70, 100, 60, paint); } ## #SeeAlso clipRect clipPath clipRegion ## #Method void clipRRect(const SkRRect& rrect, bool doAntiAlias = false) #In Clip #Populate #Example #Height 128 void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); auto oval = SkRRect::MakeRectXY({10, 20, 90, 100}, 9, 13); canvas->clipRRect(oval, true); canvas->drawCircle(70, 100, 60, paint); } ## #SeeAlso clipRect clipPath clipRegion ## #Method void clipPath(const SkPath& path, SkClipOp op, bool doAntiAlias) #In Clip #Line # combines Clip with Path ## #Populate #Example #Description Top figure uses SkPath::kInverseWinding_FillType and SkClipOp::kDifference; area outside clip is subtracted from circle. Bottom figure uses SkPath::kWinding_FillType and SkClipOp::kIntersect; area inside clip is intersected with circle. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkPath path; path.addRect({20, 30, 100, 110}); path.setFillType(SkPath::kInverseWinding_FillType); canvas->save(); canvas->clipPath(path, SkClipOp::kDifference, false); canvas->drawCircle(70, 100, 60, paint); canvas->restore(); canvas->translate(100, 100); path.setFillType(SkPath::kWinding_FillType); canvas->clipPath(path, SkClipOp::kIntersect, false); canvas->drawCircle(70, 100, 60, paint); } ## #SeeAlso clipRect clipRRect clipRegion ## #Method void clipPath(const SkPath& path, SkClipOp op) #In Clip #Populate #Example #Description Overlapping Rects form a clip. When clip Path_Fill_Type is set to SkPath::kWinding_FillType, the overlap is included. Set to SkPath::kEvenOdd_FillType, the overlap is excluded and forms a hole. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkPath path; path.addRect({20, 15, 100, 95}); path.addRect({50, 65, 130, 135}); path.setFillType(SkPath::kWinding_FillType); canvas->save(); canvas->clipPath(path, SkClipOp::kIntersect); canvas->drawCircle(70, 85, 60, paint); canvas->restore(); canvas->translate(100, 100); path.setFillType(SkPath::kEvenOdd_FillType); canvas->clipPath(path, SkClipOp::kIntersect); canvas->drawCircle(70, 85, 60, paint); } ## #SeeAlso clipRect clipRRect clipRegion ## #Method void clipPath(const SkPath& path, bool doAntiAlias = false) #In Clip #Populate #Example #Height 212 #Description Clip loops over itself covering its center twice. When clip Path_Fill_Type is set to SkPath::kWinding_FillType, the overlap is included. Set to SkPath::kEvenOdd_FillType, the overlap is excluded and forms a hole. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkPath path; SkPoint poly[] = {{20, 20}, { 80, 20}, { 80, 80}, {40, 80}, {40, 40}, {100, 40}, {100, 100}, {20, 100}}; path.addPoly(poly, SK_ARRAY_COUNT(poly), true); path.setFillType(SkPath::kWinding_FillType); canvas->save(); canvas->clipPath(path, SkClipOp::kIntersect); canvas->drawCircle(50, 50, 45, paint); canvas->restore(); canvas->translate(100, 100); path.setFillType(SkPath::kEvenOdd_FillType); canvas->clipPath(path, SkClipOp::kIntersect); canvas->drawCircle(50, 50, 45, paint); } ## #SeeAlso clipRect clipRRect clipRegion ## # ------------------------------------------------------------------------------ #Method void clipRegion(const SkRegion& deviceRgn, SkClipOp op = SkClipOp::kIntersect) #In Clip #Line # combines Clip with Region ## #Populate #Example #Description region is unaffected by canvas rotation; iRect is affected by canvas rotation. Both clips are Aliased; this is not noticeable on Region clip because it aligns to pixel boundaries. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkIRect iRect = {30, 40, 120, 130 }; SkRegion region(iRect); canvas->rotate(10); canvas->save(); canvas->clipRegion(region, SkClipOp::kIntersect); canvas->drawCircle(50, 50, 45, paint); canvas->restore(); canvas->translate(100, 100); canvas->clipRect(SkRect::Make(iRect), SkClipOp::kIntersect); canvas->drawCircle(50, 50, 45, paint); } ## #SeeAlso clipRect clipRRect clipPath ## #Method bool quickReject(const SkRect& rect) const #In Clip #Line # returns if Rect is outside Clip ## #Populate #Example void draw(SkCanvas* canvas) { SkRect testRect = {30, 30, 120, 129 }; SkRect clipRect = {30, 130, 120, 230 }; canvas->save(); canvas->clipRect(clipRect); SkDebugf("quickReject %s\n", canvas->quickReject(testRect) ? "true" : "false"); canvas->restore(); canvas->rotate(10); canvas->clipRect(clipRect); SkDebugf("quickReject %s\n", canvas->quickReject(testRect) ? "true" : "false"); } #StdOut quickReject true quickReject false ## ## #SeeAlso getLocalClipBounds getTotalMatrix SkBitmap::drawsNothing ## #Method bool quickReject(const SkPath& path) const #In Clip #Populate #Example void draw(SkCanvas* canvas) { SkPoint testPoints[] = {{30, 30}, {120, 30}, {120, 129} }; SkPoint clipPoints[] = {{30, 130}, {120, 130}, {120, 230} }; SkPath testPath, clipPath; testPath.addPoly(testPoints, SK_ARRAY_COUNT(testPoints), true); clipPath.addPoly(clipPoints, SK_ARRAY_COUNT(clipPoints), true); canvas->save(); canvas->clipPath(clipPath); SkDebugf("quickReject %s\n", canvas->quickReject(testPath) ? "true" : "false"); canvas->restore(); canvas->rotate(10); canvas->clipPath(clipPath); SkDebugf("quickReject %s\n", canvas->quickReject(testPath) ? "true" : "false"); #StdOut quickReject true quickReject false ## } ## #SeeAlso getLocalClipBounds getTotalMatrix SkBitmap::drawsNothing ## #Method SkRect getLocalClipBounds() const #In Clip #Line # returns Clip bounds in source coordinates ## #Populate #Example #Description Initial bounds is device bounds outset by 1 on all sides. Clipped bounds is clipPath bounds outset by 1 on all sides. Scaling the canvas by two on both axes scales the local bounds by 1/2 on both axes. ## SkCanvas local(256, 256); canvas = &local; SkRect bounds = canvas->getLocalClipBounds(); SkDebugf("left:%g top:%g right:%g bottom:%g\n", bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom); SkPoint clipPoints[] = {{30, 130}, {120, 130}, {120, 230} }; SkPath clipPath; clipPath.addPoly(clipPoints, SK_ARRAY_COUNT(clipPoints), true); canvas->clipPath(clipPath); bounds = canvas->getLocalClipBounds(); SkDebugf("left:%g top:%g right:%g bottom:%g\n", bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom); canvas->scale(2, 2); bounds = canvas->getLocalClipBounds(); SkDebugf("left:%g top:%g right:%g bottom:%g\n", bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom); #StdOut 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 ## ## # local canvas in example works around bug in fiddle ## #Bug 6524 #SeeAlso getDeviceClipBounds getBaseLayerSize quickReject ## #Method bool getLocalClipBounds(SkRect* bounds) const #In Clip #Populate #Example void draw(SkCanvas* canvas) { SkCanvas local(256, 256); canvas = &local; SkRect bounds; SkDebugf("local bounds empty = %s\n", canvas->getLocalClipBounds(&bounds) ? "false" : "true"); SkPath path; canvas->clipPath(path); SkDebugf("local bounds empty = %s\n", canvas->getLocalClipBounds(&bounds) ? "false" : "true"); } #StdOut local bounds empty = false local bounds empty = true ## ## # local canvas in example works around bug in fiddle ## #Bug 6524 #SeeAlso getDeviceClipBounds getBaseLayerSize quickReject ## #Method SkIRect getDeviceClipBounds() const #In Clip #Line # returns IRect bounds of Clip ## #Populate #Example void draw(SkCanvas* canvas) { #Description Initial bounds is device bounds, not outset. Clipped bounds is clipPath bounds, not outset. Scaling the canvas by 1/2 on both axes scales the device bounds by 1/2 on both axes. ## SkCanvas device(256, 256); canvas = &device; SkIRect bounds = canvas->getDeviceClipBounds(); SkDebugf("left:%d top:%d right:%d bottom:%d\n", bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom); SkPoint clipPoints[] = {{30, 130}, {120, 130}, {120, 230} }; SkPath clipPath; clipPath.addPoly(clipPoints, SK_ARRAY_COUNT(clipPoints), true); canvas->save(); canvas->clipPath(clipPath); bounds = canvas->getDeviceClipBounds(); SkDebugf("left:%d top:%d right:%d bottom:%d\n", bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom); canvas->restore(); canvas->scale(1.f/2, 1.f/2); canvas->clipPath(clipPath); bounds = canvas->getDeviceClipBounds(); SkDebugf("left:%d top:%d right:%d bottom:%d\n", bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom); #StdOut left:0 top:0 right:256 bottom:256 left:30 top:130 right:120 bottom:230 left:15 top:65 right:60 bottom:115 ## } ## #ToDo some confusion on why with an identity Matrix local and device are different ## #SeeAlso getLocalClipBounds getBaseLayerSize quickReject # device canvas in example works around bug in fiddle ## #Bug 6524 ## #Method bool getDeviceClipBounds(SkIRect* bounds) const #In Clip #Populate #Example void draw(SkCanvas* canvas) { SkIRect bounds; SkDebugf("device bounds empty = %s\n", canvas->getDeviceClipBounds(&bounds) ? "false" : "true"); SkPath path; canvas->clipPath(path); SkDebugf("device bounds empty = %s\n", canvas->getDeviceClipBounds(&bounds) ? "false" : "true"); } #StdOut device bounds empty = false device bounds empty = true ## ## #SeeAlso getLocalClipBounds getBaseLayerSize quickReject ## #Subtopic Clip ## # ------------------------------------------------------------------------------ #Subtopic Draw #Line # draws into Canvas ## ## #Method void drawColor(SkColor color, SkBlendMode mode = SkBlendMode::kSrcOver) #In Draw #Line # fills Clip with Color and Blend_Mode ## #Populate #Example canvas->drawColor(SK_ColorRED); canvas->clipRect(SkRect::MakeWH(150, 150)); canvas->drawColor(SkColorSetARGB(0x80, 0x00, 0xFF, 0x00), SkBlendMode::kPlus); canvas->clipRect(SkRect::MakeWH(75, 75)); canvas->drawColor(SkColorSetARGB(0x80, 0x00, 0x00, 0xFF), SkBlendMode::kPlus); ## #SeeAlso clear SkBitmap::erase drawPaint ## # ------------------------------------------------------------------------------ #Method void clear(SkColor color) #In Draw #Line # fills Clip with Color ## #Populate #Example void draw(SkCanvas* canvas) { canvas->save(); canvas->clipRect(SkRect::MakeWH(256, 128)); canvas->clear(SkColorSetARGB(0x80, 0xFF, 0x00, 0x00)); canvas->restore(); canvas->save(); canvas->clipRect(SkRect::MakeWH(150, 192)); canvas->clear(SkColorSetARGB(0x80, 0x00, 0xFF, 0x00)); canvas->restore(); canvas->clipRect(SkRect::MakeWH(75, 256)); canvas->clear(SkColorSetARGB(0x80, 0x00, 0x00, 0xFF)); } ## #SeeAlso drawColor SkBitmap::erase drawPaint ## # ------------------------------------------------------------------------------ #Method void discard() #In Utility #Line # makes Canvas contents undefined ## #Populate #NoExample ## #SeeAlso flush() GrContext::abandonContext ## # ------------------------------------------------------------------------------ #Method void drawPaint(const SkPaint& paint) #In Draw #Line # fills Clip with Paint ## #Populate #Example void draw(SkCanvas* canvas) { SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE }; SkScalar pos[] = { 0, SK_Scalar1/2, SK_Scalar1 }; SkPaint paint; paint.setShader(SkGradientShader::MakeSweep(256, 256, colors, pos, SK_ARRAY_COUNT(colors))); canvas->drawPaint(paint); } ## #SeeAlso clear drawColor SkBitmap::erase ## # ------------------------------------------------------------------------------ #Enum PointMode #Line # sets drawPoints options ## #Code #Populate ## Selects if an array of points are drawn as discrete points, as lines, or as an open polygon. #Const kPoints_PointMode 0 #Line # draw each point separately ## ## #Const kLines_PointMode 1 #Line # draw each pair of points as a line segment ## ## #Const kPolygon_PointMode 2 #Line # draw the array of points as a open polygon ## ## #Example #Description The upper left corner shows three squares when drawn as points. The upper right corner shows one line; when drawn as lines, two points are required per line. The lower right corner shows two lines; when draw as polygon, no miter is drawn at the corner. The lower left corner shows two lines with a miter when path contains polygon. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(10); SkPoint points[] = {{64, 32}, {96, 96}, {32, 96}}; canvas->drawPoints(SkCanvas::kPoints_PointMode, 3, points, paint); canvas->translate(128, 0); canvas->drawPoints(SkCanvas::kLines_PointMode, 3, points, paint); canvas->translate(0, 128); canvas->drawPoints(SkCanvas::kPolygon_PointMode, 3, points, paint); SkPath path; path.addPoly(points, 3, false); canvas->translate(-128, 0); canvas->drawPath(path, paint); } ## #SeeAlso drawLine drawPoint drawPath ## # ------------------------------------------------------------------------------ #Method void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) #In Draw #Line # draws array as points, lines, polygon ## #Populate #Example #Height 200 #Description #List # 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. ## void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(10); paint.setColor(0x80349a45); const SkPoint points[] = {{32, 16}, {48, 48}, {16, 32}}; const SkPaint::Join join[] = { SkPaint::kRound_Join, SkPaint::kMiter_Join, SkPaint::kBevel_Join }; int joinIndex = 0; SkPath path; path.addPoly(points, 3, false); for (const auto cap : { SkPaint::kRound_Cap, SkPaint::kSquare_Cap, SkPaint::kButt_Cap } ) { paint.setStrokeCap(cap); paint.setStrokeJoin(join[joinIndex++]); for (const auto mode : { SkCanvas::kPoints_PointMode, SkCanvas::kLines_PointMode, SkCanvas::kPolygon_PointMode } ) { canvas->drawPoints(mode, 3, points, paint); canvas->translate(64, 0); } canvas->drawPath(path, paint); canvas->translate(-192, 64); } } ## #SeeAlso drawLine drawPoint drawPath ## # ------------------------------------------------------------------------------ #Method void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint) #In Draw #Line # draws point at (x, y) position ## #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setColor(0x80349a45); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(100); paint.setStrokeCap(SkPaint::kRound_Cap); canvas->scale(1, 1.2f); canvas->drawPoint(64, 96, paint); canvas->scale(.6f, .8f); paint.setColor(SK_ColorWHITE); canvas->drawPoint(106, 120, paint); } ## #SeeAlso drawPoints drawCircle drawRect drawLine drawPath ## #Method void drawPoint(SkPoint p, const SkPaint& paint) #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setColor(0x80349a45); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(100); paint.setStrokeCap(SkPaint::kSquare_Cap); canvas->scale(1, 1.2f); canvas->drawPoint({64, 96}, paint); canvas->scale(.6f, .8f); paint.setColor(SK_ColorWHITE); canvas->drawPoint(106, 120, paint); } ## #SeeAlso drawPoints drawCircle drawRect drawLine drawPath ## # ------------------------------------------------------------------------------ #Method void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint) #In Draw #Line # draws line segment between two points ## #Populate #Example SkPaint paint; paint.setAntiAlias(true); paint.setColor(0xFF9a67be); paint.setStrokeWidth(20); canvas->skew(1, 0); canvas->drawLine(32, 96, 32, 160, paint); canvas->skew(-2, 0); canvas->drawLine(288, 96, 288, 160, paint); ## #SeeAlso drawPoint drawCircle drawRect drawPath ## #Method void drawLine(SkPoint p0, SkPoint p1, const SkPaint& paint) #Populate #Example SkPaint paint; paint.setAntiAlias(true); paint.setColor(0xFF9a67be); paint.setStrokeWidth(20); canvas->skew(1, 0); canvas->drawLine({32, 96}, {32, 160}, paint); canvas->skew(-2, 0); canvas->drawLine({288, 96}, {288, 160}, paint); ## #SeeAlso drawPoint drawCircle drawRect drawPath ## # ------------------------------------------------------------------------------ #Method void drawRect(const SkRect& rect, const SkPaint& paint) #In Draw #Line # draws Rect using Clip, Matrix, and Paint ## #Populate #Example void draw(SkCanvas* canvas) { SkPoint rectPts[] = { {64, 48}, {192, 160} }; SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(20); paint.setStrokeJoin(SkPaint::kRound_Join); SkMatrix rotator; rotator.setRotate(30, 128, 128); for (auto color : { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorMAGENTA } ) { paint.setColor(color); SkRect rect; rect.set(rectPts[0], rectPts[1]); canvas->drawRect(rect, paint); rotator.mapPoints(rectPts, 2); } } ## #SeeAlso drawIRect drawRRect drawRoundRect drawRegion drawPath drawLine ## # ------------------------------------------------------------------------------ #Method void drawIRect(const SkIRect& rect, const SkPaint& paint) #In Draw #Line # draws IRect using Clip, Matrix, and Paint ## #Populate #Example SkIRect rect = { 64, 48, 192, 160 }; SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(20); paint.setStrokeJoin(SkPaint::kRound_Join); for (auto color : { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorMAGENTA } ) { paint.setColor(color); canvas->drawIRect(rect, paint); canvas->rotate(30, 128, 128); } ## #SeeAlso drawRect drawRRect drawRoundRect drawRegion drawPath drawLine ## # ------------------------------------------------------------------------------ #Method void drawRegion(const SkRegion& region, const SkPaint& paint) #In Draw #Line # draws Region using Clip, Matrix, and Paint ## #Populate #Example void draw(SkCanvas* canvas) { SkRegion region; region.op( 10, 10, 50, 50, SkRegion::kUnion_Op); region.op( 10, 50, 90, 90, SkRegion::kUnion_Op); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(20); paint.setStrokeJoin(SkPaint::kRound_Join); canvas->drawRegion(region, paint); } ## #SeeAlso drawRect drawIRect drawPath ## # ------------------------------------------------------------------------------ #Method void drawOval(const SkRect& oval, const SkPaint& paint) #In Draw #Line # draws Oval using Clip, Matrix, and Paint ## #Populate #Example void draw(SkCanvas* canvas) { canvas->clear(0xFF3f5f9f); SkColor kColor1 = SkColorSetARGB(0xff, 0xff, 0x7f, 0); SkColor g1Colors[] = { kColor1, SkColorSetA(kColor1, 0x20) }; SkPoint g1Points[] = { { 0, 0 }, { 0, 100 } }; SkScalar pos[] = { 0.2f, 1.0f }; SkRect bounds = SkRect::MakeWH(80, 70); SkPaint paint; paint.setAntiAlias(true); paint.setShader(SkGradientShader::MakeLinear(g1Points, g1Colors, pos, SK_ARRAY_COUNT(g1Colors), SkShader::kClamp_TileMode)); canvas->drawOval(bounds , paint); } ## #SeeAlso drawCircle drawPoint drawPath drawRRect drawRoundRect ## # ------------------------------------------------------------------------------ #Method void drawRRect(const SkRRect& rrect, const SkPaint& paint) #In Draw #Line # draws Round_Rect using Clip, Matrix, and Paint ## #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkRect outer = {30, 40, 210, 220}; SkRect radii = {30, 50, 70, 90 }; SkRRect rRect; rRect.setNinePatch(outer, radii.fLeft, radii.fTop, radii.fRight, radii.fBottom); canvas->drawRRect(rRect, paint); paint.setColor(SK_ColorWHITE); canvas->drawLine(outer.fLeft + radii.fLeft, outer.fTop, outer.fLeft + radii.fLeft, outer.fBottom, paint); canvas->drawLine(outer.fRight - radii.fRight, outer.fTop, outer.fRight - radii.fRight, outer.fBottom, paint); canvas->drawLine(outer.fLeft, outer.fTop + radii.fTop, outer.fRight, outer.fTop + radii.fTop, paint); canvas->drawLine(outer.fLeft, outer.fBottom - radii.fBottom, outer.fRight, outer.fBottom - radii.fBottom, paint); } ## #SeeAlso drawRect drawRoundRect drawDRRect drawCircle drawOval drawPath ## # ------------------------------------------------------------------------------ #Method void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) #In Draw #Line # draws double Round_Rect stroked or filled ## #Populate #Example void draw(SkCanvas* canvas) { SkRRect outer = SkRRect::MakeRect({20, 40, 210, 200}); SkRRect inner = SkRRect::MakeOval({60, 70, 170, 160}); SkPaint paint; canvas->drawDRRect(outer, inner, paint); } ## #Example #Description Outer Rect has no corner radii, but stroke join is rounded. Inner Round_Rect has corner radii; outset stroke increases radii of corners. Stroke join does not affect inner Round_Rect since it has no sharp corners. ## void draw(SkCanvas* canvas) { SkRRect outer = SkRRect::MakeRect({20, 40, 210, 200}); SkRRect inner = SkRRect::MakeRectXY({60, 70, 170, 160}, 10, 10); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(20); paint.setStrokeJoin(SkPaint::kRound_Join); canvas->drawDRRect(outer, inner, paint); paint.setStrokeWidth(1); paint.setColor(SK_ColorWHITE); canvas->drawDRRect(outer, inner, paint); } ## #SeeAlso drawRect drawRoundRect drawRRect drawCircle drawOval drawPath ## # ------------------------------------------------------------------------------ #Method void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint) #In Draw #Line # draws Circle using Clip, Matrix, and Paint ## #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); canvas->drawCircle(128, 128, 90, paint); paint.setColor(SK_ColorWHITE); canvas->drawCircle(86, 86, 20, paint); canvas->drawCircle(160, 76, 20, paint); canvas->drawCircle(140, 150, 35, paint); } ## #SeeAlso drawOval drawRRect drawRoundRect drawPath drawArc drawPoint drawLine ## #Method void drawCircle(SkPoint center, SkScalar radius, const SkPaint& paint) #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); canvas->drawCircle(128, 128, 90, paint); paint.setColor(SK_ColorWHITE); canvas->drawCircle({86, 86}, 20, paint); canvas->drawCircle({160, 76}, 20, paint); canvas->drawCircle({140, 150}, 35, paint); } ## #SeeAlso drawOval drawRRect drawRoundRect drawPath drawArc drawPoint drawLine ## # ------------------------------------------------------------------------------ #Method void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint) #In Draw #Line # draws Arc using Clip, Matrix, and Paint ## #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkRect oval = { 4, 4, 60, 60}; for (auto useCenter : { false, true } ) { for (auto style : { SkPaint::kFill_Style, SkPaint::kStroke_Style } ) { paint.setStyle(style); for (auto degrees : { 45, 90, 180, 360} ) { canvas->drawArc(oval, 0, degrees , useCenter, paint); canvas->translate(64, 0); } canvas->translate(-256, 64); } } } ## #Example #Height 64 void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(4); SkRect oval = { 4, 4, 60, 60}; float intervals[] = { 5, 5 }; paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 2.5f)); for (auto degrees : { 270, 360, 540, 720 } ) { canvas->drawArc(oval, 0, degrees, false, paint); canvas->translate(64, 0); } } ## #SeeAlso SkPath::arcTo drawCircle drawOval drawPath ## # ------------------------------------------------------------------------------ #Method void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, const SkPaint& paint) #In Draw #Line # draws Round_Rect using Clip, Matrix, and Paint ## #Populate #Example #Description Top row has a zero radius a generates a rectangle. Second row radii sum to less than sides. Third row radii sum equals sides. Fourth row radii sum exceeds sides; radii are scaled to fit. ## void draw(SkCanvas* canvas) { SkVector radii[] = { {0, 20}, {10, 10}, {10, 20}, {10, 40} }; SkPaint paint; paint.setStrokeWidth(15); paint.setStrokeJoin(SkPaint::kRound_Join); paint.setAntiAlias(true); for (auto style : { SkPaint::kStroke_Style, SkPaint::kFill_Style } ) { paint.setStyle(style ); for (size_t i = 0; i < SK_ARRAY_COUNT(radii); ++i) { canvas->drawRoundRect({10, 10, 60, 40}, radii[i].fX, radii[i].fY, paint); canvas->translate(0, 60); } canvas->translate(80, -240); } } ## #SeeAlso drawRRect drawRect drawDRRect drawPath drawCircle drawOval drawPoint ## # ------------------------------------------------------------------------------ #Method void drawPath(const SkPath& path, const SkPaint& paint) #In Draw #Line # draws Path using Clip, Matrix, and Paint ## #Populate #Example #Description Top rows draw stroked path with combinations of joins and caps. The open contour is affected by caps; the closed contour is affected by joins. Bottom row draws fill the same for open and closed contour. First bottom column shows winding fills overlap. Second bottom column shows even odd fills exclude overlap. Third bottom column shows inverse winding fills area outside both contours. ## void draw(SkCanvas* canvas) { SkPath path; path.moveTo(20, 20); path.quadTo(60, 20, 60, 60); path.close(); path.moveTo(60, 20); path.quadTo(60, 60, 20, 60); SkPaint paint; paint.setStrokeWidth(10); paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); for (auto join: { SkPaint::kBevel_Join, SkPaint::kRound_Join, SkPaint::kMiter_Join } ) { paint.setStrokeJoin(join); for (auto cap: { SkPaint::kButt_Cap, SkPaint::kSquare_Cap, SkPaint::kRound_Cap } ) { paint.setStrokeCap(cap); canvas->drawPath(path, paint); canvas->translate(80, 0); } canvas->translate(-240, 60); } paint.setStyle(SkPaint::kFill_Style); for (auto fill : { SkPath::kWinding_FillType, SkPath::kEvenOdd_FillType, SkPath::kInverseWinding_FillType } ) { path.setFillType(fill); canvas->save(); canvas->clipRect({0, 10, 80, 70}); canvas->drawPath(path, paint); canvas->restore(); canvas->translate(80, 0); } } ## #SeeAlso SkPath drawLine drawArc drawRect drawPoints ## # ------------------------------------------------------------------------------ #Subtopic Draw_Image #Line # draws Image to Canvas ## 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. #Method void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr) #In Draw_Image #In Draw #Line # draws Image at (x, y) position ## #Populate #Example #Height 64 #Image 4 void draw(SkCanvas* canvas) { // sk_sp image; SkImage* imagePtr = image.get(); canvas->drawImage(imagePtr, 0, 0); SkPaint paint; canvas->drawImage(imagePtr, 80, 0, &paint); paint.setAlpha(0x80); canvas->drawImage(imagePtr, 160, 0, &paint); } ## #SeeAlso drawBitmap drawImageLattice drawImageNine drawImageRect SkPaint::setImageFilter ## # ------------------------------------------------------------------------------ #Method void drawImage(const sk_sp& image, SkScalar left, SkScalar top, const SkPaint* paint = nullptr) #Populate #Example #Height 64 #Image 4 void draw(SkCanvas* canvas) { // sk_sp image; canvas->drawImage(image, 0, 0); SkPaint paint; canvas->drawImage(image, 80, 0, &paint); paint.setAlpha(0x80); canvas->drawImage(image, 160, 0, &paint); } ## #SeeAlso drawBitmap drawImageLattice drawImageNine drawImageRect SkPaint::setImageFilter ## # ------------------------------------------------------------------------------ #Enum SrcRectConstraint #Line # sets drawImageRect options ## #Code #Populate ## 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. #Const kStrict_SrcRectConstraint 0 #Line # sample only inside bounds; slower ## Requires Image_Filter to respect source Rect, sampling only inside of its bounds, possibly with a performance penalty. ## #Const kFast_SrcRectConstraint 1 #Line # sample outside bounds; faster ## 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 #Height 64 #Description redBorder contains a black and white checkerboard bordered by red. redBorder is drawn scaled by 16 on the left. The middle and right bitmaps are filtered checkerboards. Drawing the checkerboard with kStrict_SrcRectConstraint shows only a blur of black and white. Drawing the checkerboard with kFast_SrcRectConstraint allows red to bleed in the corners. ## void draw(SkCanvas* canvas) { SkBitmap redBorder; redBorder.allocPixels(SkImageInfo::MakeN32Premul(4, 4)); SkCanvas checkRed(redBorder); checkRed.clear(SK_ColorRED); uint32_t checkers[][2] = { { SK_ColorBLACK, SK_ColorWHITE }, { SK_ColorWHITE, SK_ColorBLACK } }; checkRed.writePixels( SkImageInfo::MakeN32Premul(2, 2), (void*) checkers, sizeof(checkers[0]), 1, 1); canvas->scale(16, 16); canvas->drawBitmap(redBorder, 0, 0, nullptr); canvas->resetMatrix(); sk_sp image = SkImage::MakeFromBitmap(redBorder); SkPaint lowPaint; lowPaint.setFilterQuality(kLow_SkFilterQuality); for (auto constraint : { SkCanvas::kStrict_SrcRectConstraint, SkCanvas::kFast_SrcRectConstraint } ) { canvas->translate(80, 0); canvas->drawImageRect(image.get(), SkRect::MakeLTRB(1, 1, 3, 3), SkRect::MakeLTRB(16, 16, 48, 48), &lowPaint, constraint); } } ## #SeeAlso drawImageRect drawImage SkPaint::setImageFilter ## # ------------------------------------------------------------------------------ #Method void drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Line # draws Image, source Rect to destination Rect ## #Populate #Example #Height 64 #Description The left bitmap draws with Paint default kNone_SkFilterQuality, and stays within its bounds; there is no bleeding with kFast_SrcRectConstraint. the middle and right bitmaps draw with kLow_SkFilterQuality; with kStrict_SrcRectConstraint, the filter remains within the checkerboard, and with kFast_SrcRectConstraint red bleeds on the edges. ## void draw(SkCanvas* canvas) { uint32_t pixels[][4] = { { 0xFFFF0000, 0xFFFF0000, 0xFFFF0000, 0xFFFF0000 }, { 0xFFFF0000, 0xFF000000, 0xFFFFFFFF, 0xFFFF0000 }, { 0xFFFF0000, 0xFFFFFFFF, 0xFF000000, 0xFFFF0000 }, { 0xFFFF0000, 0xFFFF0000, 0xFFFF0000, 0xFFFF0000 } }; SkBitmap redBorder; redBorder.installPixels(SkImageInfo::MakeN32Premul(4, 4), (void*) pixels, sizeof(pixels[0])); sk_sp image = SkImage::MakeFromBitmap(redBorder); SkPaint lowPaint; for (auto constraint : { SkCanvas::kFast_SrcRectConstraint, SkCanvas::kStrict_SrcRectConstraint, SkCanvas::kFast_SrcRectConstraint } ) { canvas->drawImageRect(image.get(), SkRect::MakeLTRB(1, 1, 3, 3), SkRect::MakeLTRB(16, 16, 48, 48), &lowPaint, constraint); lowPaint.setFilterQuality(kLow_SkFilterQuality); canvas->translate(80, 0); } } ## #SeeAlso SrcRectConstraint drawImage drawImageLattice drawImageNine ## # ------------------------------------------------------------------------------ #Method void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Populate #Example #Image 4 void draw(SkCanvas* canvas) { // sk_sp image; for (auto i : { 1, 2, 4, 8 } ) { canvas->drawImageRect(image.get(), SkIRect::MakeLTRB(0, 0, 100, 100), SkRect::MakeXYWH(i * 20, i * 20, i * 20, i * 20), nullptr); } } ## #SeeAlso SrcRectConstraint drawImage drawImageLattice drawImageNine ## # ------------------------------------------------------------------------------ #Method void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint) #In Draw_Image #In Draw #Populate #Example #Image 4 void draw(SkCanvas* canvas) { // sk_sp image; for (auto i : { 20, 40, 80, 160 } ) { canvas->drawImageRect(image.get(), SkRect::MakeXYWH(i, i, i, i), nullptr); } } ## #SeeAlso SrcRectConstraint drawImage drawImageLattice drawImageNine ## # ------------------------------------------------------------------------------ #Method void drawImageRect(const sk_sp& image, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Populate #Example #Height 64 #Description Canvas scales and translates; transformation from src to dst also scales. The two matrices are concatenated to create the final transformation. ## void draw(SkCanvas* canvas) { uint32_t pixels[][2] = { { SK_ColorBLACK, SK_ColorWHITE }, { SK_ColorWHITE, SK_ColorBLACK } }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeN32Premul(2, 2), (void*) pixels, sizeof(pixels[0])); sk_sp image = SkImage::MakeFromBitmap(bitmap); SkPaint paint; canvas->scale(4, 4); for (auto alpha : { 50, 100, 150, 255 } ) { paint.setAlpha(alpha); canvas->drawImageRect(image, SkRect::MakeWH(2, 2), SkRect::MakeWH(8, 8), &paint); canvas->translate(8, 0); } } ## #SeeAlso SrcRectConstraint drawImage drawImageLattice drawImageNine ## # ------------------------------------------------------------------------------ #Method void drawImageRect(const sk_sp& image, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Populate #Example #Height 64 void draw(SkCanvas* canvas) { uint32_t pixels[][2] = { { 0x00000000, 0x55555555}, { 0xAAAAAAAA, 0xFFFFFFFF} }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeN32Premul(2, 2), (void*) pixels, sizeof(pixels[0])); sk_sp image = SkImage::MakeFromBitmap(bitmap); SkPaint paint; canvas->scale(4, 4); for (auto color : { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN } ) { paint.setColorFilter(SkColorFilter::MakeModeFilter(color, SkBlendMode::kPlus)); canvas->drawImageRect(image, SkIRect::MakeWH(2, 2), SkRect::MakeWH(8, 8), &paint); canvas->translate(8, 0); } } ## #SeeAlso SrcRectConstraint drawImage drawImageLattice drawImageNine ## # ------------------------------------------------------------------------------ #Method void drawImageRect(const sk_sp& image, const SkRect& dst, const SkPaint* paint) #In Draw_Image #In Draw #Populate #Example #Height 64 void draw(SkCanvas* canvas) { uint32_t pixels[][2] = { { 0x00000000, 0x55550000}, { 0xAAAA0000, 0xFFFF0000} }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeN32Premul(2, 2), (void*) pixels, sizeof(pixels[0])); sk_sp image = SkImage::MakeFromBitmap(bitmap); SkPaint paint; canvas->scale(4, 4); for (auto color : { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN } ) { paint.setColorFilter(SkColorFilter::MakeModeFilter(color, SkBlendMode::kPlus)); canvas->drawImageRect(image, SkRect::MakeWH(8, 8), &paint); canvas->translate(8, 0); } } ## #SeeAlso SrcRectConstraint drawImage drawImageLattice drawImageNine ## # ------------------------------------------------------------------------------ #Method void drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr) #In Draw_Image #In Draw #Line # draws Nine_Patch Image ## 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. #paint_as_used_by_draw_lattice_or_draw_nine(image)# 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. #Param image Image containing pixels, dimensions, and format ## #Param center IRect edge of image corners and sides ## #Param dst destination Rect of image to draw to ## #Param paint Paint containing Blend_Mode, Color_Filter, Image_Filter, and so on; or nullptr ## #Example #Height 128 #Description The leftmost image is smaller than center; only corners are drawn, all scaled to fit. The second image equals the size of center; only corners are drawn without scaling. The remaining images are larger than center. All corners draw without scaling. The sides and center are scaled if needed to take up the remaining space. ## void draw(SkCanvas* canvas) { SkIRect center = { 20, 10, 50, 40 }; SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(60, 60)); SkCanvas bitCanvas(bitmap); SkPaint paint; SkColor gray = 0xFF000000; int left = 0; for (auto right: { center.fLeft, center.fRight, bitmap.width() } ) { int top = 0; for (auto bottom: { center.fTop, center.fBottom, bitmap.height() } ) { paint.setColor(gray); bitCanvas.drawIRect(SkIRect::MakeLTRB(left, top, right, bottom), paint); gray += 0x001f1f1f; top = bottom; } left = right; } sk_sp image = SkImage::MakeFromBitmap(bitmap); SkImage* imagePtr = image.get(); for (auto dest: { 20, 30, 40, 60, 90 } ) { canvas->drawImageNine(imagePtr, center, SkRect::MakeWH(dest, dest), nullptr); canvas->translate(dest + 4, 0); } } ## #SeeAlso drawImage drawBitmapNine drawImageLattice drawImageRect ## # ------------------------------------------------------------------------------ #Method void drawImageNine(const sk_sp& image, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr) #In Draw_Image #In Draw 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. #paint_as_used_by_draw_lattice_or_draw_nine(image)# 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. #Param image Image containing pixels, dimensions, and format ## #Param center IRect edge of image corners and sides ## #Param dst destination Rect of image to draw to ## #Param paint Paint containing Blend_Mode, Color_Filter, Image_Filter, and so on; or nullptr ## #Example #Height 128 #Description The two leftmost images has four corners and sides to the left and right of center. The leftmost image scales the width of corners proportionately to fit. The third and fourth image corners are not scaled; the sides and center are scaled to fill the remaining space. The rightmost image has four corners scaled vertically to fit, and uses sides above and below center to fill the remaining space. ## void draw(SkCanvas* canvas) { SkIRect center = { 20, 10, 50, 40 }; SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(60, 60)); SkCanvas bitCanvas(bitmap); SkPaint paint; SkColor gray = 0xFF000000; int left = 0; for (auto right: { center.fLeft, center.fRight, bitmap.width() } ) { int top = 0; for (auto bottom: { center.fTop, center.fBottom, bitmap.height() } ) { paint.setColor(gray); bitCanvas.drawIRect(SkIRect::MakeLTRB(left, top, right, bottom), paint); gray += 0x001f1f1f; top = bottom; } left = right; } sk_sp image = SkImage::MakeFromBitmap(bitmap); for (auto dest: { 20, 30, 40, 60, 90 } ) { canvas->drawImageNine(image, center, SkRect::MakeWH(dest, 110 - dest), nullptr); canvas->translate(dest + 4, 0); } } ## #SeeAlso drawImage drawBitmapNine drawImageLattice drawImageRect ## # ------------------------------------------------------------------------------ #Method void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint = nullptr) #In Draw_Image #In Draw #Line # draws Bitmap at (x, y) position ## #Populate #Example #Height 64 void draw(SkCanvas* canvas) { uint8_t pixels[][8] = { { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00}, { 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00}, { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00}, { 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF}, { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, { 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00}, { 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0x00}, { 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF} }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeA8(8, 8), (void*) pixels, sizeof(pixels[0])); SkPaint paint; canvas->scale(4, 4); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xFF007F00} ) { paint.setColor(color); canvas->drawBitmap(bitmap, 0, 0, &paint); canvas->translate(12, 0); } } ## #SeeAlso drawImage drawBitmapLattice drawBitmapNine drawBitmapRect SkBitmap::readPixels SkBitmap::writePixels ## # ------------------------------------------------------------------------------ #Method void drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Line # draws Bitmap, source Rect to destination Rect ## #Populate #Example #Height 64 void draw(SkCanvas* canvas) { uint8_t pixels[][8] = { { 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00}, { 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00}, { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00}, { 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF}, { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, { 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00}, { 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00}, { 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00} }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeA8(8, 8), (void*) pixels, sizeof(pixels[0])); SkPaint paint; paint.setMaskFilter(SkMaskFilter::MakeBlur(kSolid_SkBlurStyle, 6)); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xFF007F00} ) { paint.setColor(color); canvas->drawBitmapRect(bitmap, SkRect::MakeWH(8, 8), SkRect::MakeWH(32, 32), &paint); canvas->translate(48, 0); } } ## #SeeAlso drawImageRect drawBitmap drawBitmapLattice drawBitmapNine ## # ------------------------------------------------------------------------------ #Method void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Populate #Example #Height 64 void draw(SkCanvas* canvas) { uint8_t pixels[][8] = { { 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00}, { 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00}, { 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF}, { 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF}, { 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF}, { 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF}, { 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00}, { 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00} }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeA8(8, 8), (void*) pixels, sizeof(pixels[0])); SkPaint paint; paint.setFilterQuality(kHigh_SkFilterQuality); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xFF007F00, 0xFF7f007f} ) { paint.setColor(color); canvas->drawBitmapRect(bitmap, SkIRect::MakeWH(8, 8), SkRect::MakeWH(32, 32), &paint); canvas->translate(48.25f, 0); } } ## #SeeAlso drawImageRect drawBitmap drawBitmapLattice drawBitmapNine ## # ------------------------------------------------------------------------------ #Method void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint, SrcRectConstraint constraint = kStrict_SrcRectConstraint) #In Draw_Image #In Draw #Populate #Example #Height 64 void draw(SkCanvas* canvas) { uint32_t pixels[][2] = { { 0x00000000, 0x55550000}, { 0xAAAA0000, 0xFFFF0000} }; SkBitmap bitmap; bitmap.installPixels(SkImageInfo::MakeN32Premul(2, 2), (void*) pixels, sizeof(pixels[0])); SkPaint paint; canvas->scale(4, 4); for (auto color : { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN } ) { paint.setColorFilter(SkColorFilter::MakeModeFilter(color, SkBlendMode::kPlus)); canvas->drawBitmapRect(bitmap, SkRect::MakeWH(8, 8), &paint); canvas->translate(8, 0); } } ## #SeeAlso drawImageRect drawBitmap drawBitmapLattice drawBitmapNine ## # ------------------------------------------------------------------------------ #PhraseDef paint_as_used_by_draw_lattice_or_draw_nine(bitmap_or_image) If Paint paint is supplied, apply Color_Filter, Color_Alpha, Image_Filter, Blend_Mode, and Draw_Looper. If #bitmap_or_image# is kAlpha_8_SkColorType, apply Shader. If paint contains Mask_Filter, generate mask from #bitmap_or_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. ## #Method void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst, const SkPaint* paint = nullptr) #In Draw_Image #In Draw #Line # draws Nine_Patch Bitmap ## 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. #paint_as_used_by_draw_lattice_or_draw_nine(bitmap)# 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. #Param bitmap Bitmap containing pixels, dimensions, and format ## #Param center IRect edge of image corners and sides ## #Param dst destination Rect of image to draw to ## #Param paint Paint containing Blend_Mode, Color_Filter, Image_Filter, and so on; or nullptr ## #Example #Height 128 #Description The two leftmost bitmap draws has four corners and sides to the left and right of center. The leftmost bitmap draw scales the width of corners proportionately to fit. The third and fourth draw corners are not scaled; the sides and center are scaled to fill the remaining space. The rightmost bitmap draw has four corners scaled vertically to fit, and uses sides above and below center to fill the remaining space. ## void draw(SkCanvas* canvas) { SkIRect center = { 20, 10, 50, 40 }; SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(60, 60)); SkCanvas bitCanvas(bitmap); SkPaint paint; SkColor gray = 0xFF000000; int left = 0; for (auto right: { center.fLeft, center.fRight, bitmap.width() } ) { int top = 0; for (auto bottom: { center.fTop, center.fBottom, bitmap.height() } ) { paint.setColor(gray); bitCanvas.drawIRect(SkIRect::MakeLTRB(left, top, right, bottom), paint); gray += 0x001f1f1f; top = bottom; } left = right; } for (auto dest: { 20, 30, 40, 60, 90 } ) { canvas->drawBitmapNine(bitmap, center, SkRect::MakeWH(dest, 110 - dest), nullptr); canvas->translate(dest + 4, 0); } } ## #SeeAlso drawImageNine drawBitmap drawBitmapLattice drawBitmapRect ## # ------------------------------------------------------------------------------ #Subtopic Lattice #Line # divides Bitmap or Image into a rectangular grid ## #Struct Lattice #Line # divides Bitmap or Image into a rectangular grid ## #Code #Populate ## 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 #Line # optional setting per rectangular grid entry ## #Code #Populate ## Optional setting per rectangular grid entry to make it transparent, or to fill the grid entry with a color. #Const kDefault 0 #Line # draws Bitmap into lattice rectangle ## ## #Const kTransparent 1 #Line # skips lattice rectangle by making it transparent ## ## #Const kFixedColor 2 #Line # draws one of fColors into lattice rectangle ## ## ## #Subtopic Members ## #Member const int* fXDivs #Line # x-axis values dividing bitmap ## 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. ## #Member const int* fYDivs #Line # y-axis values dividing bitmap ## 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. ## #Member const RectType* fRectTypes #Line # array of fill types ## Optional array of fill types, one per rectangular grid entry: array length must be #Formula # (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. ## #Member int fXCount #Line # number of x-coordinates ## Number of entries in fXDivs array; one less than the number of horizontal divisions. ## #Member int fYCount #Line # number of y-coordinates ## Number of entries in fYDivs array; one less than the number of vertical divisions. ## #Member const SkIRect* fBounds #Line # source bounds to draw from ## Optional subset IRect source to draw from. If nullptr, source bounds is dimensions of Bitmap or Image. ## #Member const SkColor* fColors #Line # array of colors ## Optional array of colors, one per rectangular grid entry. Array length must be #Formula # (fXCount + 1) * (fYCount + 1) ##. Array entries correspond to the rectangular grid entries, ascending left to right, then top to bottom. ## #Struct Lattice ## #Method void drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr) #In Draw_Image #In Draw #Line # draws proportionally stretched Bitmap ## 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. #paint_as_used_by_draw_lattice_or_draw_nine(bitmap)# 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. #Param bitmap Bitmap containing pixels, dimensions, and format ## #Param lattice division of bitmap into fixed and variable rectangles ## #Param dst destination Rect of image to draw to ## #Param paint Paint containing Blend_Mode, Color_Filter, Image_Filter, and so on; or nullptr ## #Example #Height 128 #Description The two leftmost bitmap draws has four corners and sides to the left and right of center. The leftmost bitmap draw scales the width of corners proportionately to fit. The third and fourth draw corners are not scaled; the sides are scaled to fill the remaining space; the center is transparent. The rightmost bitmap draw has four corners scaled vertically to fit, and uses sides above and below center to fill the remaining space. ## void draw(SkCanvas* canvas) { SkIRect center = { 20, 10, 50, 40 }; SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(60, 60)); SkCanvas bitCanvas(bitmap); SkPaint paint; SkColor gray = 0xFF000000; int left = 0; for (auto right: { center.fLeft, center.fRight, bitmap.width() } ) { int top = 0; for (auto bottom: { center.fTop, center.fBottom, bitmap.height() } ) { paint.setColor(gray); bitCanvas.drawIRect(SkIRect::MakeLTRB(left, top, right, bottom), paint); gray += 0x001f1f1f; top = bottom; } left = right; } const int xDivs[] = { center.fLeft, center.fRight }; const int yDivs[] = { center.fTop, center.fBottom }; SkCanvas::Lattice::RectType fillTypes[3][3]; memset(fillTypes, 0, sizeof(fillTypes)); fillTypes[1][1] = SkCanvas::Lattice::kTransparent; SkColor dummy[9]; // temporary pending bug fix SkCanvas::Lattice lattice = { xDivs, yDivs, fillTypes[0], SK_ARRAY_COUNT(xDivs), SK_ARRAY_COUNT(yDivs), nullptr, dummy }; for (auto dest: { 20, 30, 40, 60, 90 } ) { canvas->drawBitmapLattice(bitmap, lattice, SkRect::MakeWH(dest, 110 - dest), nullptr); canvas->translate(dest + 4, 0); } } ## #SeeAlso drawImageLattice drawBitmap drawBitmapNine Lattice ## # ------------------------------------------------------------------------------ #Method void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst, const SkPaint* paint = nullptr) #In Draw_Image #In Draw #Line # draws proportionally stretched Image ## 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. #paint_as_used_by_draw_lattice_or_draw_nine(image)# 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. #Param image Image containing pixels, dimensions, and format ## #Param lattice division of bitmap into fixed and variable rectangles ## #Param dst destination Rect of image to draw to ## #Param paint Paint containing Blend_Mode, Color_Filter, Image_Filter, and so on; or nullptr ## #Example #Height 128 #Description The leftmost image is smaller than center; only corners are drawn, all scaled to fit. The second image equals the size of center; only corners are drawn without scaling. The remaining images are larger than center. All corners draw without scaling. The sides are scaled if needed to take up the remaining space; the center is transparent. ## void draw(SkCanvas* canvas) { SkIRect center = { 20, 10, 50, 40 }; SkBitmap bitmap; bitmap.allocPixels(SkImageInfo::MakeN32Premul(60, 60)); SkCanvas bitCanvas(bitmap); SkPaint paint; SkColor gray = 0xFF000000; int left = 0; for (auto right: { center.fLeft, center.fRight, bitmap.width() } ) { int top = 0; for (auto bottom: { center.fTop, center.fBottom, bitmap.height() } ) { paint.setColor(gray); bitCanvas.drawIRect(SkIRect::MakeLTRB(left, top, right, bottom), paint); gray += 0x001f1f1f; top = bottom; } left = right; } sk_sp image = SkImage::MakeFromBitmap(bitmap); SkImage* imagePtr = image.get(); for (auto dest: { 20, 30, 40, 60, 90 } ) { canvas->drawImageNine(imagePtr, center, SkRect::MakeWH(dest, dest), nullptr); canvas->translate(dest + 4, 0); } } ## #SeeAlso drawBitmapLattice drawImage drawImageNine Lattice ## #Subtopic Lattice ## #Subtopic Draw_Image ## # ------------------------------------------------------------------------------ #Subtopic Draw_Text #Line # draws text into Canvas ## ## #Method void drawSimpleText(const void* text, size_t byteLength, SkTextEncoding encoding, SkScalar x, SkScalar y, const SkFont& font, const SkPaint& paint) #In Draw_Text #In Draw #Line # draws text at (x, y), using font advance ## #Populate #Example #Height 200 #Description The same text is drawn varying Paint_Text_Size and varying Matrix. ## void draw(SkCanvas* canvas) { SkPaint paint; SkFont font; float textSizes[] = { 12, 18, 24, 36 }; for (auto size: textSizes ) { font.setSize(size); canvas->drawSimpleText("Aa", 2, kUTF8_SkTextEncoding, 10, 20, font, paint); canvas->translate(0, size * 2); } font.setSize(12); float yPos = 20; for (auto size: textSizes ) { float scale = size / 12.f; canvas->resetMatrix(); canvas->translate(100, 0); canvas->scale(scale, scale); canvas->drawSimpleText("Aa", 2, kUTF8_SkTextEncoding, 10 / scale, yPos / scale, font, paint); yPos += size * 2; } } ## #SeeAlso drawString drawTextBlob ## # ------------------------------------------------------------------------------ #Method void drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint) #In Draw_Text #In Draw #Line # draws text with arrays of positions and 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: #font_metrics#. Paint_Text_Encoding must be set to kGlyphID_SkTextEncoding. 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. #Param blob Glyphs, positions, and their paints' text size, typeface, and so on ## #Param x horizontal offset applied to blob ## #Param y vertical offset applied to blob ## #Param paint blend, color, stroking, and so on, used to draw ## #Example #Height 120 void draw(SkCanvas* canvas) { SkTextBlobBuilder textBlobBuilder; const char bunny[] = "/(^x^)\\"; const int len = sizeof(bunny) - 1; uint16_t glyphs[len]; SkFont font; font.textToGlyphs(bunny, len, SkTextEncoding::kUTF8, glyphs, len); int runs[] = { 3, 1, 3 }; SkPoint textPos = { 20, 100 }; int glyphIndex = 0; for (auto runLen : runs) { font.setSize(1 == runLen ? 20 : 50); const SkTextBlobBuilder::RunBuffer& run = textBlobBuilder.allocRun(font, runLen, textPos.fX, textPos.fY); memcpy(run.glyphs, &glyphs[glyphIndex], sizeof(glyphs[0]) * runLen); font.setSize(1 == runLen ? 20 : 50); textPos.fX += font.measureText(&glyphs[glyphIndex], sizeof(glyphs[0]) * runLen, SkTextEncoding::kGlyphID); glyphIndex += runLen; } sk_sp blob = textBlobBuilder.make(); canvas->drawTextBlob(blob.get(), 0, 0, SkPaint()); } ## #SeeAlso drawText ## # ------------------------------------------------------------------------------ #Method void drawTextBlob(const sk_sp& 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: #font_metrics#. Paint_Text_Encoding must be set to kGlyphID_SkTextEncoding. Elements of paint: Path_Effect, Mask_Filter, Shader, Color_Filter, Image_Filter, and Draw_Looper; apply to blob. #Param blob Glyphs, positions, and their paints' text size, typeface, and so on ## #Param x horizontal offset applied to blob ## #Param y vertical offset applied to blob ## #Param paint blend, color, stroking, and so on, used to draw ## #Example #Height 120 #Description Paint attributes related to text, like text size, have no effect on paint passed to drawTextBlob. ## void draw(SkCanvas* canvas) { SkTextBlobBuilder textBlobBuilder; SkFont font; font.setSize(50); const SkTextBlobBuilder::RunBuffer& run = textBlobBuilder.allocRun(font, 1, 20, 100); run.glyphs[0] = 20; sk_sp blob = textBlobBuilder.make(); SkPaint paint; paint.setColor(SK_ColorBLUE); canvas->drawTextBlob(blob.get(), 0, 0, paint); } ## #SeeAlso drawText ## # ------------------------------------------------------------------------------ #Method void drawPicture(const SkPicture* picture) #In Draw #Line # draws Picture using Clip and Matrix ## #Populate #Example void draw(SkCanvas* canvas) { SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(50, 50); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xff007f00 } ) { SkPaint paint; paint.setColor(color); recordingCanvas->drawRect({10, 10, 30, 40}, paint); recordingCanvas->translate(10, 10); recordingCanvas->scale(1.2f, 1.4f); } sk_sp playback = recorder.finishRecordingAsPicture(); canvas->drawPicture(playback); canvas->scale(2, 2); canvas->translate(50, 0); canvas->drawPicture(playback); } ## #SeeAlso drawDrawable SkPicture SkPicture::playback ## # ------------------------------------------------------------------------------ #Method void drawPicture(const sk_sp& picture) #Populate #Example void draw(SkCanvas* canvas) { SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(50, 50); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xff007f00 } ) { SkPaint paint; paint.setColor(color); recordingCanvas->drawRect({10, 10, 30, 40}, paint); recordingCanvas->translate(10, 10); recordingCanvas->scale(1.2f, 1.4f); } sk_sp playback = recorder.finishRecordingAsPicture(); canvas->drawPicture(playback); canvas->scale(2, 2); canvas->translate(50, 0); canvas->drawPicture(playback); } ## #SeeAlso drawDrawable SkPicture SkPicture::playback ## # ------------------------------------------------------------------------------ #Method void drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(50, 50); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xff007f00 } ) { paint.setColor(color); recordingCanvas->drawRect({10, 10, 30, 40}, paint); recordingCanvas->translate(10, 10); recordingCanvas->scale(1.2f, 1.4f); } sk_sp playback = recorder.finishRecordingAsPicture(); const SkPicture* playbackPtr = playback.get(); SkMatrix matrix; matrix.reset(); for (auto alpha : { 70, 140, 210 } ) { paint.setAlpha(alpha); canvas->drawPicture(playbackPtr, &matrix, &paint); matrix.preTranslate(70, 70); } } ## #SeeAlso drawDrawable SkPicture SkPicture::playback ## # ------------------------------------------------------------------------------ #Method void drawPicture(const sk_sp& picture, const SkMatrix* matrix, const SkPaint* paint) #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(50, 50); for (auto color : { SK_ColorRED, SK_ColorBLUE, 0xff007f00 } ) { paint.setColor(color); recordingCanvas->drawRect({10, 10, 30, 40}, paint); recordingCanvas->translate(10, 10); recordingCanvas->scale(1.2f, 1.4f); } sk_sp playback = recorder.finishRecordingAsPicture(); SkMatrix matrix; matrix.reset(); for (auto alpha : { 70, 140, 210 } ) { paint.setAlpha(alpha); canvas->drawPicture(playback, &matrix, &paint); matrix.preTranslate(70, 70); } } ## #SeeAlso drawDrawable SkPicture SkPicture::playback ## # ------------------------------------------------------------------------------ #Method void drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint) #In Draw #Line # draws Vertices, a triangle mesh ## #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; SkPoint points[] = { { 0, 0 }, { 250, 0 }, { 100, 100 }, { 0, 250 } }; SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorCYAN }; auto vertices = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, SK_ARRAY_COUNT(points), points, nullptr, colors); canvas->drawVertices(vertices.get(), SkBlendMode::kSrc, paint); } ## #SeeAlso drawPatch drawPicture ## # ------------------------------------------------------------------------------ #Method void drawVertices(const sk_sp& vertices, SkBlendMode mode, const SkPaint& paint) #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; SkPoint points[] = { { 0, 0 }, { 250, 0 }, { 100, 100 }, { 0, 250 } }; SkPoint texs[] = { { 0, 0 }, { 0, 250 }, { 250, 250 }, { 250, 0 } }; SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorCYAN }; paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 4, SkShader::kClamp_TileMode)); auto vertices = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, SK_ARRAY_COUNT(points), points, texs, colors); canvas->drawVertices(vertices, SkBlendMode::kDarken, paint); } ## #SeeAlso drawPatch drawPicture ## # ------------------------------------------------------------------------------ #Method void drawVertices(const SkVertices* vertices, const SkVertices::Bone bones[], int boneCount, SkBlendMode mode, const SkPaint& paint) #Populate #NoExample void draw(SkCanvas* canvas) { SkPaint paint; SkPoint points[] = { { 0, 0 }, { 250, 0 }, { 100, 100 }, { 0, 250 } }; SkPoint texs[] = { { 0, 0 }, { 0, 250 }, { 250, 250 }, { 250, 0 } }; SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorCYAN }; SkVertices::BoneIndices boneIndices[] = { { 0, 0, 0, 0 }, { 1, 0, 0, 0 }, { 2, 0, 0, 0 }, { 3, 0, 0, 0 } }; SkVertices::BoneWeights boneWeights[] = { { 0.0f, 0.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f } }; SkVertices::Bone bones[] = { {{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }}, {{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 20.0f }}, {{ 1.0f, 0.0f, 0.0f, 1.0f, 50.0f, 50.0f }}, {{ 1.0f, 0.0f, 0.0f, 1.0f, 20.0f, 0.0f }} }; paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 4, SkShader::kClamp_TileMode)); auto vertices = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, SK_ARRAY_COUNT(points), points, texs, colors, boneIndices, boneWeights); canvas->drawVertices(vertices.get(), bones, SK_ARRAY_COUNT(bones), SkBlendMode::kDarken, paint); } ## #SeeAlso drawPatch drawPicture ## # ------------------------------------------------------------------------------ #Method void drawVertices(const sk_sp& vertices, const SkVertices::Bone bones[], int boneCount, SkBlendMode mode, const SkPaint& paint) #Populate #NoExample void draw(SkCanvas* canvas) { SkPaint paint; SkPoint points[] = { { 0, 0 }, { 250, 0 }, { 100, 100 }, { 0, 250 } }; SkPoint texs[] = { { 0, 0 }, { 0, 250 }, { 250, 250 }, { 250, 0 } }; SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorCYAN }; SkVertices::BoneIndices boneIndices[] = { { 0, 0, 0, 0 }, { 1, 0, 0, 0 }, { 2, 0, 0, 0 }, { 3, 0, 0, 0 } }; SkVertices::BoneWeights boneWeights[] = { { 0.0f, 0.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f } }; SkVertices::Bone bones[] = { {{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }}, {{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 20.0f }}, {{ 1.0f, 0.0f, 0.0f, 1.0f, 50.0f, 50.0f }}, {{ 1.0f, 0.0f, 0.0f, 1.0f, 20.0f, 0.0f }} }; paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 4, SkShader::kClamp_TileMode)); auto vertices = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, SK_ARRAY_COUNT(points), points, texs, colors, boneIndices, boneWeights); canvas->drawVertices(vertices, bones, SK_ARRAY_COUNT(bones), SkBlendMode::kDarken, paint); } ## #SeeAlso drawPatch drawPicture ## # ------------------------------------------------------------------------------ #Method void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint) #In Draw #Line # draws Coons_Patch ## #Populate #Example #Image 5 void draw(SkCanvas* canvas) { // SkBitmap source = cmbkygk; SkPaint paint; paint.setFilterQuality(kLow_SkFilterQuality); paint.setAntiAlias(true); SkPoint cubics[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 }, /* { 7, 3 }, */ { 6, 4 }, { 7, 5 }, { 5, 7 }, /* { 5, 7 }, */ { 4, 6 }, { 3, 7 }, { 1, 5 }, /* { 1, 5 }, */ { 2, 4 }, { 1, 3 }, /* { 3, 1 } */ }; SkColor colors[] = { 0xbfff0000, 0xbf0000ff, 0xbfff00ff, 0xbf00ffff }; SkPoint texCoords[] = { { -30, -30 }, { 162, -30}, { 162, 162}, { -30, 162} }; paint.setShader(SkShader::MakeBitmapShader(source, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr)); canvas->scale(15, 15); for (auto blend : { SkBlendMode::kSrcOver, SkBlendMode::kModulate, SkBlendMode::kXor } ) { canvas->drawPatch(cubics, colors, texCoords, blend, paint); canvas->translate(4, 4); } } ## #ToDo can patch use image filter? ## #SeeAlso drawVertices drawPicture ## # ------------------------------------------------------------------------------ #Method void drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], const SkPaint& paint) #Populate #Example void draw(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); SkPoint cubics[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 }, /* { 7, 3 }, */ { 6, 4 }, { 7, 5 }, { 5, 7 }, /* { 5, 7 }, */ { 4, 6 }, { 3, 7 }, { 1, 5 }, /* { 1, 5 }, */ { 2, 4 }, { 1, 3 }, /* { 3, 1 } */ }; SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorYELLOW, SK_ColorCYAN }; canvas->scale(30, 30); canvas->drawPatch(cubics, colors, nullptr, paint); SkPoint text[] = { {3,0.9f}, {4,2.5f}, {5,0.9f}, {7.5f,3.2f}, {5.5f,4.2f}, {7.5f,5.2f}, {5,7.5f}, {4,5.9f}, {3,7.5f}, {0.5f,5.2f}, {2.5f,4.2f}, {0.5f,3.2f} }; SkFont font(nullptr, 18.f / 30); for (int i = 0; i< 10; ++i) { char digit = '0' + i; canvas->drawSimpleText(&digit, kUTF8_SkTextEncoding, 1, text[i].fX, text[i].fY, font, paint); } canvas->drawString("10", text[10].fX, text[10].fY, font, paint); canvas->drawString("11", text[11].fX, text[11].fY, font, paint); paint.setStyle(SkPaint::kStroke_Style); canvas->drawPoints(SkCanvas::kPolygon_PointMode, 12, cubics, paint); canvas->drawLine(cubics[11].fX, cubics[11].fY, cubics[0].fX, cubics[0].fY, paint); } ## #Example #Image 6 void draw(SkCanvas* canvas) { // SkBitmap source = checkerboard; SkPaint paint; paint.setFilterQuality(kLow_SkFilterQuality); paint.setAntiAlias(true); SkPoint cubics[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 }, /* { 7, 3 }, */ { 6, 4 }, { 7, 5 }, { 5, 7 }, /* { 5, 7 }, */ { 4, 6 }, { 3, 7 }, { 1, 5 }, /* { 1, 5 }, */ { 2, 4 }, { 1, 3 }, /* { 3, 1 } */ }; SkPoint texCoords[] = { { 0, 0 }, { 0, 62}, { 62, 62}, { 62, 0 } }; paint.setShader(SkShader::MakeBitmapShader(source, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, nullptr)); canvas->scale(30, 30); canvas->drawPatch(cubics, nullptr, texCoords, paint); } ## #ToDo can patch use image filter? ## #SeeAlso drawVertices drawPicture ## # ------------------------------------------------------------------------------ #Method void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint) #In Draw #Line # draws sprites using Clip, Matrix, and Paint ## #Populate #Example #Image 3 void draw(SkCanvas* canvas) { // SkBitmap source = mandrill; SkRSXform xforms[] = { { .5f, 0, 0, 0 }, {0, .5f, 200, 100 } }; SkRect tex[] = { { 0, 0, 250, 250 }, { 0, 0, 250, 250 } }; SkColor colors[] = { 0x7f55aa00, 0x7f3333bf }; const SkImage* imagePtr = image.get(); canvas->drawAtlas(imagePtr, xforms, tex, colors, 2, SkBlendMode::kSrcOver, nullptr, nullptr); } ## #SeeAlso drawBitmap drawImage ## # ------------------------------------------------------------------------------ #Method void drawAtlas(const sk_sp& atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkRect* cullRect, const SkPaint* paint) #Populate #Example #Image 3 void draw(SkCanvas* canvas) { // SkBitmap source = mandrill; SkRSXform xforms[] = { { .5f, 0, 0, 0 }, {0, .5f, 200, 100 } }; SkRect tex[] = { { 0, 0, 250, 250 }, { 0, 0, 250, 250 } }; SkColor colors[] = { 0x7f55aa00, 0x7f3333bf }; SkPaint paint; paint.setAlpha(127); canvas->drawAtlas(image, xforms, tex, colors, 2, SkBlendMode::kPlus, nullptr, &paint); } ## #ToDo bug in example on cpu side, gpu looks ok ## #SeeAlso drawBitmap drawImage ## # ------------------------------------------------------------------------------ #Method void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint) #Populate #Example #Image 3 void draw(SkCanvas* canvas) { // sk_sp image = mandrill; SkRSXform xforms[] = { { .5f, 0, 0, 0 }, {0, .5f, 200, 100 } }; SkRect tex[] = { { 0, 0, 250, 250 }, { 0, 0, 250, 250 } }; const SkImage* imagePtr = image.get(); canvas->drawAtlas(imagePtr, xforms, tex, 2, nullptr, nullptr); } ## #SeeAlso drawBitmap drawImage ## # ------------------------------------------------------------------------------ #Method void drawAtlas(const sk_sp& atlas, const SkRSXform xform[], const SkRect tex[], int count, const SkRect* cullRect, const SkPaint* paint) #Populate #Example #Image 3 void draw(SkCanvas* canvas) { // sk_sp image = mandrill; SkRSXform xforms[] = { { 1, 0, 0, 0 }, {0, 1, 300, 100 } }; SkRect tex[] = { { 0, 0, 200, 200 }, { 200, 0, 400, 200 } }; canvas->drawAtlas(image, xforms, tex, 2, nullptr, nullptr); } ## #SeeAlso drawBitmap drawImage ## # ------------------------------------------------------------------------------ #Method void drawDrawable(SkDrawable* drawable, const SkMatrix* matrix = nullptr) #In Draw #Line # draws Drawable, encapsulated drawing commands ## #Populate #Example #Height 100 #Function struct MyDrawable : public SkDrawable { SkRect onGetBounds() override { return SkRect::MakeWH(50, 100); } void onDraw(SkCanvas* canvas) override { SkPath path; path.conicTo(10, 90, 50, 90, 0.9f); SkPaint paint; paint.setColor(SK_ColorBLUE); canvas->drawRect(path.getBounds(), paint); paint.setAntiAlias(true); paint.setColor(SK_ColorWHITE); canvas->drawPath(path, paint); } }; #Function ## void draw(SkCanvas* canvas) { sk_sp drawable(new MyDrawable); SkMatrix matrix; matrix.setTranslate(10, 10); canvas->drawDrawable(drawable.get(), &matrix); } ## #SeeAlso SkDrawable drawPicture ## # ------------------------------------------------------------------------------ #Method void drawDrawable(SkDrawable* drawable, SkScalar x, SkScalar y) #Populate #Example #Height 100 #Function struct MyDrawable : public SkDrawable { SkRect onGetBounds() override { return SkRect::MakeWH(50, 100); } void onDraw(SkCanvas* canvas) override { SkPath path; path.conicTo(10, 90, 50, 90, 0.9f); SkPaint paint; paint.setColor(SK_ColorBLUE); canvas->drawRect(path.getBounds(), paint); paint.setAntiAlias(true); paint.setColor(SK_ColorWHITE); canvas->drawPath(path, paint); } }; #Function ## void draw(SkCanvas* canvas) { sk_sp drawable(new MyDrawable); canvas->drawDrawable(drawable.get(), 10, 10); } ## #SeeAlso SkDrawable drawPicture ## # ------------------------------------------------------------------------------ #Method void drawAnnotation(const SkRect& rect, const char key[], SkData* value) #In Draw #In Utility #Line # associates a Rect with a key-value pair ## #Populate #Example #Height 1 const char text[] = "Click this link!"; SkRect bounds; SkPaint paint; SkFont font(nullptr, 40); (void)font.measureText(text, strlen(text), SkTextEncoding::kUTF8, &bounds); const char url[] = "https://www.google.com/"; sk_sp urlData(SkData::MakeWithCString(url)); canvas->drawAnnotation(bounds, "url_key", urlData.get()); ## #SeeAlso SkPicture SkDocument ## # ------------------------------------------------------------------------------ #Method void drawAnnotation(const SkRect& rect, const char key[], const sk_sp& value) #Populate #Example #Height 1 const char text[] = "Click this link!"; SkRect bounds; SkPaint paint; SkFont font(nullptr, 40); (void)font.measureText(text, strlen(text), SkTextEncoding::kUTF8, &bounds); const char url[] = "https://www.google.com/"; sk_sp urlData(SkData::MakeWithCString(url)); canvas->drawAnnotation(bounds, "url_key", urlData.get()); ## #SeeAlso SkPicture SkDocument ## # ------------------------------------------------------------------------------ #Method virtual bool isClipEmpty() const #In Property #Line # returns if Clip is empty ## #Populate #Example void draw(SkCanvas* canvas) { SkDebugf("clip is%s empty\n", canvas->isClipEmpty() ? "" : " not"); SkPath path; canvas->clipPath(path); SkDebugf("clip is%s empty\n", canvas->isClipEmpty() ? "" : " not"); } #StdOut clip is not empty clip is empty ## ## #SeeAlso isClipRect getLocalClipBounds getDeviceClipBounds ## # ------------------------------------------------------------------------------ #Method virtual bool isClipRect() const #In Property #Line # returns if Clip is Rect and not empty ## #Populate #Example void draw(SkCanvas* canvas) { SkDebugf("clip is%s rect\n", canvas->isClipRect() ? "" : " not"); canvas->clipRect({0, 0, 0, 0}); SkDebugf("clip is%s rect\n", canvas->isClipRect() ? "" : " not"); } #StdOut clip is rect clip is not rect ## ## #SeeAlso isClipEmpty getLocalClipBounds getDeviceClipBounds ## #Class SkCanvas ## #Topic Canvas ##