Canvas

restore everything when restore() is called

restore the current clip when restore() is called

clip against the layer's bounds

the layer needs to 8-bits per color component

the layer needs to per-pixel alpha

restore the current matrix when restore() is called

Construct an empty raster canvas. Use setBitmap() to specify a bitmap to draw into. The initial target density is DENSITY_NONE; this will typically be replaced when a target bitmap is set for the canvas.

Construct a canvas with the specified bitmap to draw into. The bitmap must be mutable.

The initial target density of the canvas is the same as the given bitmap's density.

Construct a canvas with the specified gl context. All drawing through this canvas will be redirected to OpenGL. Note: some features may not be supported in this mode (e.g. some GL implementations may not support antialiasing or certain effects like ColorMatrix or certain Xfermodes). However, no exception will be thrown in those cases.

The initial target density of the canvas is the same as the initial density of bitmaps as per Bitmap.getDensity().

Intersect the current clip with the specified path.

Modify the current clip with the specified path.

Modify the current clip with the specified rectangle, which is expressed in local coordinates.

Modify the current clip with the specified rectangle.

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

Modify the current clip with the specified rectangle, which is expressed in local coordinates.

Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

Intersect the current clip with the specified region. Note that unlike clipRect() and clipPath() which transform their arguments by the current matrix, clipRegion() assumes its argument is already in the coordinate system of the current layer's bitmap, and so not transformation is performed.

Modify the current clip with the specified region. Note that unlike clipRect() and clipPath() which transform their arguments by the current matrix, clipRegion() assumes its argument is already in the coordinate system of the current layer's bitmap, and so not transformation is performed.

Preconcat the current matrix with the specified matrix.

Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB color, using srcover porterduff mode.

Draw the specified arc, which will be scaled to fit inside the specified oval. If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs slightly from SkPath::arcTo, which treats the sweep angle mod 360.

Treat the specified array of colors as a bitmap, and draw it. This gives the same result as first creating a bitmap from the array, and then drawing it, but this method avoids explicitly creating a bitmap object which can be more efficient if the colors are changing often.

Draw the bitmap using the specified matrix.

Legacy version of drawBitmap(int[] colors, ...) that took ints for x,y

Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to draw.

Note: if the paint contains a maskfilter that generates a mask which extends beyond the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be the edge color replicated.

This function ignores the density associated with the bitmap. This is because the source and destination rectangle coordinate spaces are in their respective densities, so must already have the appropriate scaling factor applied.

Draw the specified bitmap, with its top/left corner at (x,y), using the specified paint, transformed by the current matrix.

Note: if the paint contains a maskfilter that generates a mask which extends beyond the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be the edge color replicated.

If the bitmap and canvas have different densities, this function will take care of automatically scaling the bitmap to draw at the same density as the canvas.

Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to draw.

Note: if the paint contains a maskfilter that generates a mask which extends beyond the bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be the edge color replicated.

This function ignores the density associated with the bitmap. This is because the source and destination rectangle coordinate spaces are in their respective densities, so must already have the appropriate scaling factor applied.

Draw the bitmap through the mesh, where mesh vertices are evenly distributed across the bitmap. There are meshWidth+1 vertices across, and meshHeight+1 vertices down. The verts array is accessed in row-major order, so that the first meshWidth+1 vertices are distributed across the top of the bitmap from left to right. A more general version of this methid is drawVertices().

Draw the specified circle using the specified paint. If radius is <= 0, then nothing will be drawn. The circle will be filled or framed based on the Style in the paint.

Fill the entire canvas' bitmap (restricted to the current clip) with the specified color, using srcover porterduff mode.

Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and porter-duff xfermode.

Draw a line segment with the specified start and stop x,y coordinates, using the specified paint. NOTE: since a line is always "framed", the Style is ignored in the paint.

Draw a series of lines. Each line is taken from 4 consecutive values in the pts array. Thus to draw 1 line, the array must contain at least 4 values. This is logically the same as drawing the array as follows: drawLine(pts[0], pts[1], pts[2], pts[3]) followed by drawLine(pts[4], pts[5], pts[6], pts[7]) and so on.

Draw the specified oval using the specified paint. The oval will be filled or framed based on the Style in the paint.

Fill the entire canvas' bitmap (restricted to the current clip) with the specified paint. This is equivalent (but faster) to drawing an infinitely large rectangle with the specified paint.

Draw the specified path using the specified paint. The path will be filled or framed based on the Style in the paint.

Draw the picture, stretched to fit into the dst rectangle.

Save the canvas state, draw the picture, and restore the canvas state. This differs from picture.draw(canvas), which does not perform any save/restore.

Draw the picture, stretched to fit into the dst rectangle.

Helper for drawPoints() for drawing a single point.

Draw a series of points. Each point is centered at the coordinate specified by pts[], and its diameter is specified by the paint's stroke width (as transformed by the canvas' CTM), with special treatment for a stroke width of 0, which always draws exactly 1 pixel (or at most 4 if antialiasing is enabled). The shape of the point is controlled by the paint's Cap type. The shape is a square, unless the cap type is Round, in which case the shape is a circle.

Helper for drawPoints() that assumes you want to draw the entire array

Draw the text in the array, with each character's origin specified by the pos array.

Draw the text in the array, with each character's origin specified by the pos array.

Fill the entire canvas' bitmap (restricted to the current clip) with the specified RGB color, using srcover porterduff mode.

Draw the specified Rect using the specified paint. The rectangle will be filled or framed based on the Style in the paint.

Draw the specified Rect using the specified paint. The rectangle will be filled or framed based on the Style in the paint.

Draw the specified Rect using the specified Paint. The rectangle will be filled or framed based on the Style in the paint.

Draw the specified round-rect using the specified paint. The roundrect will be filled or framed based on the Style in the paint.

Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted based on the Align setting in the paint.

Draw the specified range of text, specified by start/end, with its origin at (x,y), in the specified Paint. The origin is interpreted based on the Align setting in the Paint.

Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted based on the Align setting in the paint.

Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted based on the Align setting in the paint.

Draw the text, with origin at (x,y), using the specified paint, along the specified path. The paint's Align setting determins where along the path to start the text.

Draw the text, with origin at (x,y), using the specified paint, along the specified path. The paint's Align setting determins where along the path to start the text.

Draw the array of vertices, interpreted as triangles (based on mode). The verts array is required, and specifies the x,y pairs for each vertex. If texs is non-null, then it is used to specify the coordinate in shader coordinates to use at each vertex (the paint must have a shader in this case). If there is no texs array, but there is a color array, then each color is interpolated across its corresponding triangle in a gradient. If both texs and colors arrays are present, then they behave as before, but the resulting color at each pixels is the result of multiplying the colors from the shader and the color-gradient together. The indices array is optional, but if it is present, then it is used to specify the index of each triangle, rather than just walking through the arrays in order.

Call this to free up OpenGL resources that may be cached or allocated on behalf of the Canvas. Any subsequent drawing with a GL-backed Canvas will have to recreate those resources.

Retrieve the clip bounds.

Retrieve the clip bounds, returning true if they are non-empty.

Returns the target density of the canvas. The default density is derived from the density of its backing bitmap, or DENSITY_NONE if there is not one.

Return the GL object associated with this canvas, or null if it is not backed by GL.

Returns the height of the current drawing layer

Return, in ctm, the current transformation matrix. This does not alter the matrix in the canvas, but just returns a copy of it.

Return a new matrix with a copy of the canvas' current transformation matrix.

Returns the number of matrix/clip states on the Canvas' private stack. This will equal # save() calls - # restore() calls.

Returns the width of the current drawing layer

Return true if the device that the current layer draws into is opaque (i.e. does not support per-pixel alpha).

Return true if the specified path, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls). Note: for speed it may return false even if the path itself might not intersect the clip (i.e. the bounds of the path intersects, but the path does not).

Return true if the specified rectangle, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls).

Return true if the specified rectangle, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls).

This call balances a previous call to save(), and is used to remove all modifications to the matrix/clip state since the last save call. It is an error to call restore() more times than save() was called.

Efficient way to pop any calls to save() that happened after the save count reached saveCount. It is an error for saveCount to be less than 1. Example: int count = canvas.save(); ... // more calls potentially to save() canvas.restoreToCount(count); // now the canvas is back in the same state it was before the initial // call to save().

Preconcat the current matrix with the specified rotation.

Preconcat the current matrix with the specified rotation.

Saves the current matrix and clip onto a private stack. Subsequent calls to translate,scale,rotate,skew,concat or clipRect,clipPath will all operate as usual, but when the balancing call to restore() is made, those calls will be forgotten, and the settings that existed before the save() will be reinstated.

Based on saveFlags, can save the current matrix and clip onto a private stack. Subsequent calls to translate,scale,rotate,skew,concat or clipRect,clipPath will all operate as usual, but when the balancing call to restore() is made, those calls will be forgotten, and the settings that existed before the save() will be reinstated.

This behaves the same as save(), but in addition it allocates an offscreen bitmap. All drawing calls are directed there, and only when the balancing call to restore() is made is that offscreen transfered to the canvas (or the previous layer). Subsequent calls to translate, scale, rotate, skew, concat or clipRect, clipPath all operate on this copy. When the balancing call to restore() is made, this copy is deleted and the previous matrix/clip state is restored.

Helper version of saveLayer() that takes 4 values rather than a RectF.

This behaves the same as save(), but in addition it allocates an offscreen bitmap. All drawing calls are directed there, and only when the balancing call to restore() is made is that offscreen transfered to the canvas (or the previous layer). Subsequent calls to translate, scale, rotate, skew, concat or clipRect, clipPath all operate on this copy. When the balancing call to restore() is made, this copy is deleted and the previous matrix/clip state is restored.

Helper for saveLayerAlpha() that takes 4 values instead of a RectF.

Preconcat the current matrix with the specified scale.

Preconcat the current matrix with the specified scale.

Specify a bitmap for the canvas to draw into. As a side-effect, also updates the canvas's target density to match that of the bitmap.

Specifies the density for this Canvas' backing bitmap. This modifies the target density of the canvas itself, as well as the density of its backing bitmap via Bitmap.setDensity(int).

Completely replace the current matrix with the specified matrix. If the matrix parameter is null, then the current matrix is reset to identity.

Set the viewport dimensions if this canvas is GL based. If it is not, this method is ignored and no exception is thrown.

Preconcat the current matrix with the specified skew.

Preconcat the current matrix with the specified translation

Called before the object's memory is reclaimed by the VM. This can only happen once the garbage collector has detected that the object is no longer reachable by any thread of the running application.

The method can be used to free system resources or perform other cleanup before the object is garbage collected. The default implementation of the method is empty, which is also expected by the VM, but subclasses can override finalize() as required. Uncaught exceptions which are thrown during the execution of this method cause it to terminate immediately but are otherwise ignored.

Note that the VM does guarantee that finalize() is called at most once for any object, but it doesn't guarantee when (if at all) finalize() will be called. For example, object B's finalize() can delay the execution of object A's finalize() method and therefore it can delay the reclamation of A's memory. To be safe, use a ReferenceQueue, because it provides more control over the way the VM deals with references during garbage collection.