FileDocCategorySizeDatePackage
Canvas.javaAPI DocAndroid 5.1 API89981Thu Mar 12 22:22:30 GMT 2015android.graphics

Canvas

public class Canvas extends Object
The Canvas class holds the "draw" calls. To draw something, you need 4 basic components: A Bitmap to hold the pixels, a Canvas to host the draw calls (writing into the bitmap), a drawing primitive (e.g. Rect, Path, text, Bitmap), and a paint (to describe the colors and styles for the drawing).

Developer Guides

For more information about how to use Canvas, read the Canvas and Drawables developer guide.

Fields Summary
private long
mNativeCanvasWrapper
private Bitmap
mBitmap
private DrawFilter
mDrawFilter
protected int
mDensity
protected int
mScreenDensity
Used to determine when compatibility scaling is in effect.
private int
mSurfaceFormat
public static final int
DIRECTION_LTR
Flag for drawTextRun indicating left-to-right run direction.
public static final int
DIRECTION_RTL
Flag for drawTextRun indicating right-to-left run direction.
private static final int
MAXMIMUM_BITMAP_SIZE
private final CanvasFinalizer
mFinalizer
public static final int
MATRIX_SAVE_FLAG
Restore the current matrix when restore() is called.
public static final int
CLIP_SAVE_FLAG
Restore the current clip when restore() is called.
public static final int
HAS_ALPHA_LAYER_SAVE_FLAG
The layer requires a per-pixel alpha channel.
public static final int
FULL_COLOR_LAYER_SAVE_FLAG
The layer requires full 8-bit precision for each color channel.
public static final int
CLIP_TO_LAYER_SAVE_FLAG
Clip drawing to the bounds of the offscreen layer, omit at your own peril.

Note: it is strongly recommended to not omit this flag for any call to saveLayer() and saveLayerAlpha() variants. Not passing this flag generally triggers extremely poor performance with hardware accelerated rendering.

public static final int
ALL_SAVE_FLAG
Restore everything when restore() is called (standard save flags).

Note: for performance reasons, it is strongly recommended to pass this - the complete set of flags - to any call to saveLayer() and saveLayerAlpha() variants.

Constructors Summary
public Canvas()
Construct an empty raster canvas. Use setBitmap() to specify a bitmap to draw into. The initial target density is {@link Bitmap#DENSITY_NONE}; this will typically be replaced when a target bitmap is set for the canvas.

        if (!isHardwareAccelerated()) {
            // 0 means no native bitmap
            mNativeCanvasWrapper = initRaster(0);
            mFinalizer = new CanvasFinalizer(mNativeCanvasWrapper);
        } else {
            mFinalizer = null;
        }
public Canvas(Bitmap bitmap)
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.

param
bitmap Specifies a mutable bitmap for the canvas to draw into.

        if (!bitmap.isMutable()) {
            throw new IllegalStateException("Immutable bitmap passed to Canvas constructor");
        }
        throwIfCannotDraw(bitmap);
        mNativeCanvasWrapper = initRaster(bitmap.ni());
        mFinalizer = new CanvasFinalizer(mNativeCanvasWrapper);
        mBitmap = bitmap;
        mDensity = bitmap.mDensity;
public Canvas(long nativeCanvas)

hide

        if (nativeCanvas == 0) {
            throw new IllegalStateException();
        }
        mNativeCanvasWrapper = nativeCanvas;
        mFinalizer = new CanvasFinalizer(mNativeCanvasWrapper);
        mDensity = Bitmap.getDefaultDensity();
Methods Summary
protected static voidcheckRange(int length, int offset, int count)

hide

        if ((offset | count) < 0 || offset + count > length) {
            throw new ArrayIndexOutOfBoundsException();
        }
public booleanclipPath(Path path, Region.Op op)
Modify the current clip with the specified path.

param
path The path to operate on the current clip
param
op How the clip is modified
return
true if the resulting is non-empty

        return native_clipPath(mNativeCanvasWrapper, path.ni(), op.nativeInt);
public booleanclipPath(Path path)
Intersect the current clip with the specified path.

param
path The path to intersect with the current clip
return
true if the resulting is non-empty

        return clipPath(path, Region.Op.INTERSECT);
public booleanclipRect(RectF rect, Region.Op op)
Modify the current clip with the specified rectangle.

param
rect The rect to intersect with the current clip
param
op How the clip is modified
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom,
                op.nativeInt);
public booleanclipRect(Rect rect, Region.Op op)
Modify the current clip with the specified rectangle, which is expressed in local coordinates.

param
rect The rectangle to intersect with the current clip.
param
op How the clip is modified
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom,
                op.nativeInt);
public booleanclipRect(RectF rect)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

param
rect The rectangle to intersect with the current clip.
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom,
                Region.Op.INTERSECT.nativeInt);
public booleanclipRect(Rect rect)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

param
rect The rectangle to intersect with the current clip.
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom,
                Region.Op.INTERSECT.nativeInt);
public booleanclipRect(float left, float top, float right, float bottom, Region.Op op)
Modify the current clip with the specified rectangle, which is expressed in local coordinates.

param
left The left side of the rectangle to intersect with the current clip
param
top The top of the rectangle to intersect with the current clip
param
right The right side of the rectangle to intersect with the current clip
param
bottom The bottom of the rectangle to intersect with the current clip
param
op How the clip is modified
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, left, top, right, bottom, op.nativeInt);
public booleanclipRect(float left, float top, float right, float bottom)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

param
left The left side of the rectangle to intersect with the current clip
param
top The top of the rectangle to intersect with the current clip
param
right The right side of the rectangle to intersect with the current clip
param
bottom The bottom of the rectangle to intersect with the current clip
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, left, top, right, bottom,
                Region.Op.INTERSECT.nativeInt);
public booleanclipRect(int left, int top, int right, int bottom)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

param
left The left side of the rectangle to intersect with the current clip
param
top The top of the rectangle to intersect with the current clip
param
right The right side of the rectangle to intersect with the current clip
param
bottom The bottom of the rectangle to intersect with the current clip
return
true if the resulting clip is non-empty

        return native_clipRect(mNativeCanvasWrapper, left, top, right, bottom,
                Region.Op.INTERSECT.nativeInt);
public booleanclipRegion(Region region, Region.Op op)
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.

param
region The region to operate on the current clip, based on op
param
op How the clip is modified
return
true if the resulting is non-empty
deprecated
Unlike all other clip calls this API does not respect the current matrix. Use {@link #clipRect(Rect)} as an alternative.

        return native_clipRegion(mNativeCanvasWrapper, region.ni(), op.nativeInt);
public booleanclipRegion(Region region)
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.

param
region The region to operate on the current clip, based on op
return
true if the resulting is non-empty
deprecated
Unlike all other clip calls this API does not respect the current matrix. Use {@link #clipRect(Rect)} as an alternative.

        return clipRegion(region, Region.Op.INTERSECT);
public voidconcat(Matrix matrix)
Preconcat the current matrix with the specified matrix. If the specified matrix is null, this method does nothing.

param
matrix The matrix to preconcatenate with the current matrix

        if (matrix != null) native_concat(mNativeCanvasWrapper, matrix.native_instance);
public voiddrawARGB(int a, int r, int g, int b)
Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB color, using srcover porterduff mode.

param
a alpha component (0..255) of the color to draw onto the canvas
param
r red component (0..255) of the color to draw onto the canvas
param
g green component (0..255) of the color to draw onto the canvas
param
b blue component (0..255) of the color to draw onto the canvas

        drawColor(Color.argb(a, r, g, b));
public voiddrawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter, Paint paint)

Draw the specified arc, which will be scaled to fit inside the specified oval.

If the start angle is negative or >= 360, the start angle is treated as start angle modulo 360.

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 modulo 360. If the sweep angle is negative, the sweep angle is treated as sweep angle modulo 360

The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 degrees (3 o'clock on a watch.)

param
oval The bounds of oval used to define the shape and size of the arc
param
startAngle Starting angle (in degrees) where the arc begins
param
sweepAngle Sweep angle (in degrees) measured clockwise
param
useCenter If true, include the center of the oval in the arc, and close it if it is being stroked. This will draw a wedge
param
paint The paint used to draw the arc

        drawArc(oval.left, oval.top, oval.right, oval.bottom, startAngle, sweepAngle, useCenter,
                paint);
public voiddrawArc(float left, float top, float right, float bottom, float startAngle, float sweepAngle, boolean useCenter, Paint paint)

Draw the specified arc, which will be scaled to fit inside the specified oval.

If the start angle is negative or >= 360, the start angle is treated as start angle modulo 360.

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 modulo 360. If the sweep angle is negative, the sweep angle is treated as sweep angle modulo 360

The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 degrees (3 o'clock on a watch.)

param
startAngle Starting angle (in degrees) where the arc begins
param
sweepAngle Sweep angle (in degrees) measured clockwise
param
useCenter If true, include the center of the oval in the arc, and close it if it is being stroked. This will draw a wedge
param
paint The paint used to draw the arc

        native_drawArc(mNativeCanvasWrapper, left, top, right, bottom, startAngle, sweepAngle,
                useCenter, paint.mNativePaint);
public voiddrawBitmap(Bitmap bitmap, float left, float top, Paint paint)
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.

param
bitmap The bitmap to be drawn
param
left The position of the left side of the bitmap being drawn
param
top The position of the top side of the bitmap being drawn
param
paint The paint used to draw the bitmap (may be null)

        throwIfCannotDraw(bitmap);
        native_drawBitmap(mNativeCanvasWrapper, bitmap.ni(), left, top,
                paint != null ? paint.mNativePaint : 0, mDensity, mScreenDensity, bitmap.mDensity);
public voiddrawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint)
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.

param
bitmap The bitmap to be drawn
param
src May be null. The subset of the bitmap to be drawn
param
dst The rectangle that the bitmap will be scaled/translated to fit into
param
paint May be null. The paint used to draw the bitmap

      if (dst == null) {
          throw new NullPointerException();
      }
      throwIfCannotDraw(bitmap);
      final long nativePaint = paint == null ? 0 : paint.mNativePaint;

      float left, top, right, bottom;
      if (src == null) {
          left = top = 0;
          right = bitmap.getWidth();
          bottom = bitmap.getHeight();
      } else {
          left = src.left;
          right = src.right;
          top = src.top;
          bottom = src.bottom;
      }

      native_drawBitmap(mNativeCanvasWrapper, bitmap.ni(), left, top, right, bottom,
              dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity,
              bitmap.mDensity);
public voiddrawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint)
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.

param
bitmap The bitmap to be drawn
param
src May be null. The subset of the bitmap to be drawn
param
dst The rectangle that the bitmap will be scaled/translated to fit into
param
paint May be null. The paint used to draw the bitmap

        if (dst == null) {
            throw new NullPointerException();
        }
        throwIfCannotDraw(bitmap);
        final long nativePaint = paint == null ? 0 : paint.mNativePaint;

        int left, top, right, bottom;
        if (src == null) {
            left = top = 0;
            right = bitmap.getWidth();
            bottom = bitmap.getHeight();
        } else {
            left = src.left;
            right = src.right;
            top = src.top;
            bottom = src.bottom;
        }

        native_drawBitmap(mNativeCanvasWrapper, bitmap.ni(), left, top, right, bottom,
            dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity,
            bitmap.mDensity);
public voiddrawBitmap(int[] colors, int offset, int stride, float x, float y, int width, int height, boolean hasAlpha, Paint paint)
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.

param
colors Array of colors representing the pixels of the bitmap
param
offset Offset into the array of colors for the first pixel
param
stride The number of colors in the array between rows (must be >= width or <= -width).
param
x The X coordinate for where to draw the bitmap
param
y The Y coordinate for where to draw the bitmap
param
width The width of the bitmap
param
height The height of the bitmap
param
hasAlpha True if the alpha channel of the colors contains valid values. If false, the alpha byte is ignored (assumed to be 0xFF for every pixel).
param
paint May be null. The paint used to draw the bitmap
deprecated
Usage with a {@link #isHardwareAccelerated() hardware accelerated} canvas requires an internal copy of color buffer contents every time this method is called. Using a Bitmap avoids this copy, and allows the application to more explicitly control the lifetime and copies of pixel data.

        // check for valid input
        if (width < 0) {
            throw new IllegalArgumentException("width must be >= 0");
        }
        if (height < 0) {
            throw new IllegalArgumentException("height must be >= 0");
        }
        if (Math.abs(stride) < width) {
            throw new IllegalArgumentException("abs(stride) must be >= width");
        }
        int lastScanline = offset + (height - 1) * stride;
        int length = colors.length;
        if (offset < 0 || (offset + width > length) || lastScanline < 0
                || (lastScanline + width > length)) {
            throw new ArrayIndexOutOfBoundsException();
        }
        // quick escape if there's nothing to draw
        if (width == 0 || height == 0) {
            return;
        }
        // punch down to native for the actual draw
        native_drawBitmap(mNativeCanvasWrapper, colors, offset, stride, x, y, width, height, hasAlpha,
                paint != null ? paint.mNativePaint : 0);
public voiddrawBitmap(int[] colors, int offset, int stride, int x, int y, int width, int height, boolean hasAlpha, Paint paint)
Legacy version of drawBitmap(int[] colors, ...) that took ints for x,y

deprecated
Usage with a {@link #isHardwareAccelerated() hardware accelerated} canvas requires an internal copy of color buffer contents every time this method is called. Using a Bitmap avoids this copy, and allows the application to more explicitly control the lifetime and copies of pixel data.

        // call through to the common float version
        drawBitmap(colors, offset, stride, (float)x, (float)y, width, height,
                   hasAlpha, paint);
public voiddrawBitmap(Bitmap bitmap, Matrix matrix, Paint paint)
Draw the bitmap using the specified matrix.

param
bitmap The bitmap to draw
param
matrix The matrix used to transform the bitmap when it is drawn
param
paint May be null. The paint used to draw the bitmap

        nativeDrawBitmapMatrix(mNativeCanvasWrapper, bitmap.ni(), matrix.ni(),
                paint != null ? paint.mNativePaint : 0);
public voiddrawBitmapMesh(Bitmap bitmap, int meshWidth, int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset, Paint paint)
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 method is drawVertices().

param
bitmap The bitmap to draw using the mesh
param
meshWidth The number of columns in the mesh. Nothing is drawn if this is 0
param
meshHeight The number of rows in the mesh. Nothing is drawn if this is 0
param
verts Array of x,y pairs, specifying where the mesh should be drawn. There must be at least (meshWidth+1) * (meshHeight+1) * 2 + vertOffset values in the array
param
vertOffset Number of verts elements to skip before drawing
param
colors May be null. Specifies a color at each vertex, which is interpolated across the cell, and whose values are multiplied by the corresponding bitmap colors. If not null, there must be at least (meshWidth+1) * (meshHeight+1) + colorOffset values in the array.
param
colorOffset Number of color elements to skip before drawing
param
paint May be null. The paint used to draw the bitmap

        if ((meshWidth | meshHeight | vertOffset | colorOffset) < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
        if (meshWidth == 0 || meshHeight == 0) {
            return;
        }
        int count = (meshWidth + 1) * (meshHeight + 1);
        // we mul by 2 since we need two floats per vertex
        checkRange(verts.length, vertOffset, count * 2);
        if (colors != null) {
            // no mul by 2, since we need only 1 color per vertex
            checkRange(colors.length, colorOffset, count);
        }
        nativeDrawBitmapMesh(mNativeCanvasWrapper, bitmap.ni(), meshWidth, meshHeight,
                verts, vertOffset, colors, colorOffset,
                paint != null ? paint.mNativePaint : 0);
public voiddrawCircle(float cx, float cy, float radius, Paint paint)
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.

param
cx The x-coordinate of the center of the cirle to be drawn
param
cy The y-coordinate of the center of the cirle to be drawn
param
radius The radius of the cirle to be drawn
param
paint The paint used to draw the circle

        native_drawCircle(mNativeCanvasWrapper, cx, cy, radius, paint.mNativePaint);
public voiddrawColor(int color)
Fill the entire canvas' bitmap (restricted to the current clip) with the specified color, using srcover porterduff mode.

param
color the color to draw onto the canvas

        native_drawColor(mNativeCanvasWrapper, color, PorterDuff.Mode.SRC_OVER.nativeInt);
public voiddrawColor(int color, PorterDuff.Mode mode)
Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and porter-duff xfermode.

param
color the color to draw with
param
mode the porter-duff mode to apply to the color

        native_drawColor(mNativeCanvasWrapper, color, mode.nativeInt);
public voiddrawLine(float startX, float startY, float stopX, float stopY, Paint paint)
Draw a line segment with the specified start and stop x,y coordinates, using the specified paint.

Note that since a line is always "framed", the Style is ignored in the paint.

Degenerate lines (length is 0) will not be drawn.

param
startX The x-coordinate of the start point of the line
param
startY The y-coordinate of the start point of the line
param
paint The paint used to draw the line

        native_drawLine(mNativeCanvasWrapper, startX, startY, stopX, stopY, paint.mNativePaint);
public voiddrawLines(float[] pts, int offset, int count, Paint 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.

param
pts Array of points to draw [x0 y0 x1 y1 x2 y2 ...]
param
offset Number of values in the array to skip before drawing.
param
count The number of values in the array to process, after skipping "offset" of them. Since each line uses 4 values, the number of "lines" that are drawn is really (count >> 2).
param
paint The paint used to draw the points

        native_drawLines(mNativeCanvasWrapper, pts, offset, count, paint.mNativePaint);
public voiddrawLines(float[] pts, Paint paint)

        drawLines(pts, 0, pts.length, paint);
public voiddrawOval(RectF oval, Paint paint)
Draw the specified oval using the specified paint. The oval will be filled or framed based on the Style in the paint.

param
oval The rectangle bounds of the oval to be drawn

        if (oval == null) {
            throw new NullPointerException();
        }
        drawOval(oval.left, oval.top, oval.right, oval.bottom, paint);
public voiddrawOval(float left, float top, float right, float bottom, Paint paint)
Draw the specified oval using the specified paint. The oval will be filled or framed based on the Style in the paint.

        native_drawOval(mNativeCanvasWrapper, left, top, right, bottom, paint.mNativePaint);
public voiddrawPaint(Paint 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.

param
paint The paint used to draw onto the canvas

        native_drawPaint(mNativeCanvasWrapper, paint.mNativePaint);
public voiddrawPatch(NinePatch patch, Rect dst, Paint paint)
Draws the specified bitmap as an N-patch (most often, a 9-patches.)

param
patch The ninepatch object to render
param
dst The destination rectangle.
param
paint The paint to draw the bitmap with. may be null
hide

        patch.drawSoftware(this, dst, paint);
public voiddrawPatch(NinePatch patch, RectF dst, Paint paint)
Draws the specified bitmap as an N-patch (most often, a 9-patches.)

param
patch The ninepatch object to render
param
dst The destination rectangle.
param
paint The paint to draw the bitmap with. may be null
hide

        patch.drawSoftware(this, dst, paint);
public voiddrawPath(Path path, Paint paint)
Draw the specified path using the specified paint. The path will be filled or framed based on the Style in the paint.

param
path The path to be drawn
param
paint The paint used to draw the path

        native_drawPath(mNativeCanvasWrapper, path.ni(), paint.mNativePaint);
public voiddrawPicture(Picture picture)
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.

Note: This forces the picture to internally call {@link Picture#endRecording} in order to prepare for playback.

param
picture The picture to be drawn

        picture.endRecording();
        int restoreCount = save();
        picture.draw(this);
        restoreToCount(restoreCount);
public voiddrawPicture(Picture picture, RectF dst)
Draw the picture, stretched to fit into the dst rectangle.

        save();
        translate(dst.left, dst.top);
        if (picture.getWidth() > 0 && picture.getHeight() > 0) {
            scale(dst.width() / picture.getWidth(), dst.height() / picture.getHeight());
        }
        drawPicture(picture);
        restore();
public voiddrawPicture(Picture picture, Rect dst)
Draw the picture, stretched to fit into the dst rectangle.

        save();
        translate(dst.left, dst.top);
        if (picture.getWidth() > 0 && picture.getHeight() > 0) {
            scale((float) dst.width() / picture.getWidth(),
                    (float) dst.height() / picture.getHeight());
        }
        drawPicture(picture);
        restore();
public voiddrawPoint(float x, float y, Paint paint)
Helper for drawPoints() for drawing a single point.

        native_drawPoint(mNativeCanvasWrapper, x, y, paint.mNativePaint);
public voiddrawPoints(float[] pts, int offset, int count, Paint paint)
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.

param
pts Array of points to draw [x0 y0 x1 y1 x2 y2 ...]
param
offset Number of values to skip before starting to draw.
param
count The number of values to process, after skipping offset of them. Since one point uses two values, the number of "points" that are drawn is really (count >> 1).
param
paint The paint used to draw the points

        native_drawPoints(mNativeCanvasWrapper, pts, offset, count, paint.mNativePaint);
public voiddrawPoints(float[] pts, Paint paint)
Helper for drawPoints() that assumes you want to draw the entire array

        drawPoints(pts, 0, pts.length, paint);
public voiddrawPosText(char[] text, int index, int count, float[] pos, Paint paint)
Draw the text in the array, with each character's origin specified by the pos array. This method does not support glyph composition and decomposition and should therefore not be used to render complex scripts. It also doesn't handle supplementary characters (eg emoji).

param
text The text to be drawn
param
index The index of the first character to draw
param
count The number of characters to draw, starting from index.
param
pos Array of [x,y] positions, used to position each character
param
paint The paint used for the text (e.g. color, size, style)

        if (index < 0 || index + count > text.length || count*2 > pos.length) {
            throw new IndexOutOfBoundsException();
        }
        for (int i = 0; i < count; i++) {
            drawText(text, index + i, 1, pos[i * 2], pos[i * 2 + 1], paint);
        }
public voiddrawPosText(java.lang.String text, float[] pos, Paint paint)
Draw the text in the array, with each character's origin specified by the pos array. This method does not support glyph composition and decomposition and should therefore not be used to render complex scripts. It also doesn't handle supplementary characters (eg emoji).

param
text The text to be drawn
param
pos Array of [x,y] positions, used to position each character
param
paint The paint used for the text (e.g. color, size, style)

        drawPosText(text.toCharArray(), 0, text.length(), pos, paint);
public voiddrawRGB(int r, int g, int b)
Fill the entire canvas' bitmap (restricted to the current clip) with the specified RGB color, using srcover porterduff mode.

param
r red component (0..255) of the color to draw onto the canvas
param
g green component (0..255) of the color to draw onto the canvas
param
b blue component (0..255) of the color to draw onto the canvas

        drawColor(Color.rgb(r, g, b));
public voiddrawRect(RectF rect, Paint paint)
Draw the specified Rect using the specified paint. The rectangle will be filled or framed based on the Style in the paint.

param
rect The rect to be drawn
param
paint The paint used to draw the rect

        native_drawRect(mNativeCanvasWrapper,
                rect.left, rect.top, rect.right, rect.bottom, paint.mNativePaint);
public voiddrawRect(Rect r, Paint paint)
Draw the specified Rect using the specified Paint. The rectangle will be filled or framed based on the Style in the paint.

param
r The rectangle to be drawn.
param
paint The paint used to draw the rectangle

        drawRect(r.left, r.top, r.right, r.bottom, paint);
public voiddrawRect(float left, float top, float right, float bottom, Paint paint)
Draw the specified Rect using the specified paint. The rectangle will be filled or framed based on the Style in the paint.

param
left The left side of the rectangle to be drawn
param
top The top side of the rectangle to be drawn
param
right The right side of the rectangle to be drawn
param
bottom The bottom side of the rectangle to be drawn
param
paint The paint used to draw the rect

        native_drawRect(mNativeCanvasWrapper, left, top, right, bottom, paint.mNativePaint);
public voiddrawRoundRect(RectF rect, float rx, float ry, Paint paint)
Draw the specified round-rect using the specified paint. The roundrect will be filled or framed based on the Style in the paint.

param
rect The rectangular bounds of the roundRect to be drawn
param
rx The x-radius of the oval used to round the corners
param
ry The y-radius of the oval used to round the corners
param
paint The paint used to draw the roundRect

        drawRoundRect(rect.left, rect.top, rect.right, rect.bottom, rx, ry, paint);
public voiddrawRoundRect(float left, float top, float right, float bottom, float rx, float ry, Paint paint)
Draw the specified round-rect using the specified paint. The roundrect will be filled or framed based on the Style in the paint.

param
rx The x-radius of the oval used to round the corners
param
ry The y-radius of the oval used to round the corners
param
paint The paint used to draw the roundRect

        native_drawRoundRect(mNativeCanvasWrapper, left, top, right, bottom, rx, ry, paint.mNativePaint);
public voiddrawText(java.lang.CharSequence text, int start, int end, float x, float y, Paint 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.

param
text The text to be drawn
param
start The index of the first character in text to draw
param
end (end - 1) is the index of the last character in text to draw
param
x The x-coordinate of origin for where to draw the text
param
y The y-coordinate of origin for where to draw the text
param
paint The paint used for the text (e.g. color, size, style)

        if ((start | end | (end - start) | (text.length() - end)) < 0) {
            throw new IndexOutOfBoundsException();
        }
        if (text instanceof String || text instanceof SpannedString ||
            text instanceof SpannableString) {
            native_drawText(mNativeCanvasWrapper, text.toString(), start, end, x, y,
                    paint.mBidiFlags, paint.mNativePaint, paint.mNativeTypeface);
        } else if (text instanceof GraphicsOperations) {
            ((GraphicsOperations) text).drawText(this, start, end, x, y,
                    paint);
        } else {
            char[] buf = TemporaryBuffer.obtain(end - start);
            TextUtils.getChars(text, start, end, buf, 0);
            native_drawText(mNativeCanvasWrapper, buf, 0, end - start, x, y,
                    paint.mBidiFlags, paint.mNativePaint, paint.mNativeTypeface);
            TemporaryBuffer.recycle(buf);
        }
public voiddrawText(char[] text, int index, int count, float x, float y, Paint 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.

param
text The text to be drawn
param
x The x-coordinate of the origin of the text being drawn
param
y The y-coordinate of the origin of the text being drawn
param
paint The paint used for the text (e.g. color, size, style)

        if ((index | count | (index + count) |
            (text.length - index - count)) < 0) {
            throw new IndexOutOfBoundsException();
        }
        native_drawText(mNativeCanvasWrapper, text, index, count, x, y, paint.mBidiFlags,
                paint.mNativePaint, paint.mNativeTypeface);
public voiddrawText(java.lang.String text, float x, float y, Paint 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.

param
text The text to be drawn
param
x The x-coordinate of the origin of the text being drawn
param
y The y-coordinate of the origin of the text being drawn
param
paint The paint used for the text (e.g. color, size, style)

        native_drawText(mNativeCanvasWrapper, text, 0, text.length(), x, y, paint.mBidiFlags,
                paint.mNativePaint, paint.mNativeTypeface);
public voiddrawText(java.lang.String text, int start, int end, float x, float y, Paint 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.

param
text The text to be drawn
param
start The index of the first character in text to draw
param
end (end - 1) is the index of the last character in text to draw
param
x The x-coordinate of the origin of the text being drawn
param
y The y-coordinate of the origin of the text being drawn
param
paint The paint used for the text (e.g. color, size, style)

        if ((start | end | (end - start) | (text.length() - end)) < 0) {
            throw new IndexOutOfBoundsException();
        }
        native_drawText(mNativeCanvasWrapper, text, start, end, x, y, paint.mBidiFlags,
                paint.mNativePaint, paint.mNativeTypeface);
public voiddrawTextOnPath(char[] text, int index, int count, Path path, float hOffset, float vOffset, Paint 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.

param
text The text to be drawn
param
path The path the text should follow for its baseline
param
hOffset The distance along the path to add to the text's starting position
param
vOffset The distance above(-) or below(+) the path to position the text
param
paint The paint used for the text (e.g. color, size, style)

        if (index < 0 || index + count > text.length) {
            throw new ArrayIndexOutOfBoundsException();
        }
        native_drawTextOnPath(mNativeCanvasWrapper, text, index, count,
                path.ni(), hOffset, vOffset,
                paint.mBidiFlags, paint.mNativePaint, paint.mNativeTypeface);
public voiddrawTextOnPath(java.lang.String text, Path path, float hOffset, float vOffset, Paint 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.

param
text The text to be drawn
param
path The path the text should follow for its baseline
param
hOffset The distance along the path to add to the text's starting position
param
vOffset The distance above(-) or below(+) the path to position the text
param
paint The paint used for the text (e.g. color, size, style)

        if (text.length() > 0) {
            native_drawTextOnPath(mNativeCanvasWrapper, text, path.ni(), hOffset, vOffset,
                    paint.mBidiFlags, paint.mNativePaint, paint.mNativeTypeface);
        }
public voiddrawTextRun(char[] text, int index, int count, int contextIndex, int contextCount, float x, float y, boolean isRtl, Paint paint)
Render a run of all LTR or all RTL text, with shaping. This does not run bidi on the provided text, but renders it as a uniform right-to-left or left-to-right run, as indicated by dir. Alignment of the text is as determined by the Paint's TextAlign value.

param
text the text to render
param
index the start of the text to render
param
count the count of chars to render
param
contextIndex the start of the context for shaping. Must be no greater than index.
param
contextCount the number of characters in the context for shaping. ContexIndex + contextCount must be no less than index + count.
param
x the x position at which to draw the text
param
y the y position at which to draw the text
param
isRtl whether the run is in RTL direction
param
paint the paint
hide


        if (text == null) {
            throw new NullPointerException("text is null");
        }
        if (paint == null) {
            throw new NullPointerException("paint is null");
        }
        if ((index | count | text.length - index - count) < 0) {
            throw new IndexOutOfBoundsException();
        }

        native_drawTextRun(mNativeCanvasWrapper, text, index, count,
                contextIndex, contextCount, x, y, isRtl, paint.mNativePaint, paint.mNativeTypeface);
public voiddrawTextRun(java.lang.CharSequence text, int start, int end, int contextStart, int contextEnd, float x, float y, boolean isRtl, Paint paint)
Render a run of all LTR or all RTL text, with shaping. This does not run bidi on the provided text, but renders it as a uniform right-to-left or left-to-right run, as indicated by dir. Alignment of the text is as determined by the Paint's TextAlign value.

param
text the text to render
param
start the start of the text to render. Data before this position can be used for shaping context.
param
end the end of the text to render. Data at or after this position can be used for shaping context.
param
x the x position at which to draw the text
param
y the y position at which to draw the text
param
isRtl whether the run is in RTL direction
param
paint the paint
hide


        if (text == null) {
            throw new NullPointerException("text is null");
        }
        if (paint == null) {
            throw new NullPointerException("paint is null");
        }
        if ((start | end | end - start | text.length() - end) < 0) {
            throw new IndexOutOfBoundsException();
        }

        if (text instanceof String || text instanceof SpannedString ||
                text instanceof SpannableString) {
            native_drawTextRun(mNativeCanvasWrapper, text.toString(), start, end,
                    contextStart, contextEnd, x, y, isRtl, paint.mNativePaint, paint.mNativeTypeface);
        } else if (text instanceof GraphicsOperations) {
            ((GraphicsOperations) text).drawTextRun(this, start, end,
                    contextStart, contextEnd, x, y, isRtl, paint);
        } else {
            int contextLen = contextEnd - contextStart;
            int len = end - start;
            char[] buf = TemporaryBuffer.obtain(contextLen);
            TextUtils.getChars(text, contextStart, contextEnd, buf, 0);
            native_drawTextRun(mNativeCanvasWrapper, buf, start - contextStart, len,
                    0, contextLen, x, y, isRtl, paint.mNativePaint, paint.mNativeTypeface);
            TemporaryBuffer.recycle(buf);
        }
public voiddrawVertices(android.graphics.Canvas$VertexMode mode, int vertexCount, float[] verts, int vertOffset, float[] texs, int texOffset, int[] colors, int colorOffset, short[] indices, int indexOffset, int indexCount, Paint paint)
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.

param
mode How to interpret the array of vertices
param
vertexCount The number of values in the vertices array (and corresponding texs and colors arrays if non-null). Each logical vertex is two values (x, y), vertexCount must be a multiple of 2.
param
verts Array of vertices for the mesh
param
vertOffset Number of values in the verts to skip before drawing.
param
texs May be null. If not null, specifies the coordinates to sample into the current shader (e.g. bitmap tile or gradient)
param
texOffset Number of values in texs to skip before drawing.
param
colors May be null. If not null, specifies a color for each vertex, to be interpolated across the triangle.
param
colorOffset Number of values in colors to skip before drawing.
param
indices If not null, array of indices to reference into the vertex (texs, colors) array.
param
indexCount number of entries in the indices array (if not null).
param
paint Specifies the shader to use if the texs array is non-null.

        checkRange(verts.length, vertOffset, vertexCount);
        if (texs != null) {
            checkRange(texs.length, texOffset, vertexCount);
        }
        if (colors != null) {
            checkRange(colors.length, colorOffset, vertexCount / 2);
        }
        if (indices != null) {
            checkRange(indices.length, indexOffset, indexCount);
        }
        nativeDrawVertices(mNativeCanvasWrapper, mode.nativeInt, vertexCount, verts,
                vertOffset, texs, texOffset, colors, colorOffset,
                indices, indexOffset, indexCount, paint.mNativePaint);
private static native voidfinalizer(long nativeCanvas)

public static native voidfreeCaches()
Free up as much memory as possible from private caches (e.g. fonts, images)
hide
public static native voidfreeTextLayoutCaches()
Free up text layout caches
hide
public booleangetClipBounds(Rect bounds)
Return the bounds of the current clip (in local coordinates) in the
bounds parameter, and return true if it is non-empty. This can be useful
in a way similar to quickReject, in that it tells you that drawing
outside of these bounds will be clipped out.
param
bounds Return the clip bounds here. If it is null, ignore it but
still return true if the current clip is non-empty.
return
true if the current clip is non-empty.
        return native_getClipBounds(mNativeCanvasWrapper, bounds);
    
public final RectgetClipBounds()
Retrieve the bounds of the current clip (in local coordinates).
return
the clip bounds, or [0, 0, 0, 0] if the clip is empty.
        Rect r = new Rect();
        getClipBounds(r);
        return r;
    
public intgetDensity()
Returns the target density of the canvas. The default density is
derived from the density of its backing bitmap, or
{@link Bitmap#DENSITY_NONE} if there is not one.
return
Returns the current target density of the canvas, which is used
to determine the scaling factor when drawing a bitmap into it.
see
#setDensity(int)
see
Bitmap#getDensity()
        return mDensity;
    
public DrawFiltergetDrawFilter()
        return mDrawFilter;
    
protected javax.microedition.khronos.opengles.GLgetGL()
Returns null.
deprecated
This method is not supported and should not be invoked.
hide
        return null;
    
public intgetHeight()
Returns the height of the current drawing layer
return
the height of the current drawing layer
        return native_getHeight(mNativeCanvasWrapper);
    
public voidgetMatrix(Matrix ctm)
Return, in ctm, the current transformation matrix. This does not alter
the matrix in the canvas, but just returns a copy of it.
        native_getCTM(mNativeCanvasWrapper, ctm.native_instance);
    
public final MatrixgetMatrix()
Return a new matrix with a copy of the canvas' current transformation
matrix.
        Matrix m = new Matrix();
        //noinspection deprecation
        getMatrix(m);
        return m;
    
public intgetMaximumBitmapHeight()
Returns the maximum allowed height for bitmaps drawn with this canvas.
Attempting to draw with a bitmap taller than this value will result
in an error.
see
#getMaximumBitmapWidth()
        return MAXMIMUM_BITMAP_SIZE;
    
public intgetMaximumBitmapWidth()
Returns the maximum allowed width for bitmaps drawn with this canvas.
Attempting to draw with a bitmap wider than this value will result
in an error.
see
#getMaximumBitmapHeight()
        return MAXMIMUM_BITMAP_SIZE;
    
public longgetNativeCanvasWrapper()
hide
        return mNativeCanvasWrapper;
    
public intgetSaveCount()
Returns the number of matrix/clip states on the Canvas' private stack.
This will equal # save() calls - # restore() calls.
        return native_getSaveCount(mNativeCanvasWrapper);
    
public intgetWidth()
Returns the width of the current drawing layer
return
the width of the current drawing layer
        return native_getWidth(mNativeCanvasWrapper);
    
private static native longinitRaster(long nativeBitmapOrZero)
public voidinsertInorderBarrier()
hide
public voidinsertReorderBarrier()
hide
public booleanisHardwareAccelerated()
Indicates whether this Canvas uses hardware acceleration.

Note that this method does not define what type of hardware acceleration
may or may not be used.
return
True if drawing operations are hardware accelerated,
false otherwise.
        return false;
    
public booleanisOpaque()
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 device that the current layer draws into is opaque
        return native_isOpaque(mNativeCanvasWrapper);
    
public booleanisRecordingFor(java.lang.Object o)
hide
 return false; 
private static native voidnativeDrawBitmapMatrix(long nativeCanvas, long nativeBitmap, long nativeMatrix, long nativePaint)
private static native voidnativeDrawBitmapMesh(long nativeCanvas, long nativeBitmap, int meshWidth, int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset, long nativePaint)
private static native voidnativeDrawVertices(long nativeCanvas, int mode, int n, float[] verts, int vertOffset, float[] texs, int texOffset, int[] colors, int colorOffset, short[] indices, int indexOffset, int indexCount, long nativePaint)
private static native voidnativeSetDrawFilter(long nativeCanvas, long nativeFilter)
private static native booleannative_clipPath(long nativeCanvas, long nativePath, int regionOp)
private static native booleannative_clipRect(long nativeCanvas, float left, float top, float right, float bottom, int regionOp)
private static native booleannative_clipRegion(long nativeCanvas, long nativeRegion, int regionOp)
private static native voidnative_concat(long nativeCanvas, long nativeMatrix)
private static native voidnative_drawArc(long nativeCanvas, float left, float top, float right, float bottom, float startAngle, float sweep, boolean useCenter, long nativePaint)
private native voidnative_drawBitmap(long nativeCanvas, long nativeBitmap, float left, float top, long nativePaintOrZero, int canvasDensity, int screenDensity, int bitmapDensity)
private native voidnative_drawBitmap(long nativeCanvas, long nativeBitmap, float srcLeft, float srcTop, float srcRight, float srcBottom, float dstLeft, float dstTop, float dstRight, float dstBottom, long nativePaintOrZero, int screenDensity, int bitmapDensity)
private static native voidnative_drawBitmap(long nativeCanvas, int[] colors, int offset, int stride, float x, float y, int width, int height, boolean hasAlpha, long nativePaintOrZero)
private static native voidnative_drawCircle(long nativeCanvas, float cx, float cy, float radius, long nativePaint)
private static native voidnative_drawColor(long nativeCanvas, int color, int mode)
private static native voidnative_drawLine(long nativeCanvas, float startX, float startY, float stopX, float stopY, long nativePaint)
private static native voidnative_drawLines(long canvasHandle, float[] pts, int offset, int count, long paintHandle)
private static native voidnative_drawOval(long nativeCanvas, float left, float top, float right, float bottom, long nativePaint)
private static native voidnative_drawPaint(long nativeCanvas, long nativePaint)
private static native voidnative_drawPath(long nativeCanvas, long nativePath, long nativePaint)
private static native voidnative_drawPoint(long canvasHandle, float x, float y, long paintHandle)
private static native voidnative_drawPoints(long canvasHandle, float[] pts, int offset, int count, long paintHandle)
private static native voidnative_drawRect(long nativeCanvas, float left, float top, float right, float bottom, long nativePaint)
private static native voidnative_drawRoundRect(long nativeCanvas, float left, float top, float right, float bottom, float rx, float ry, long nativePaint)
private static native voidnative_drawText(long nativeCanvas, char[] text, int index, int count, float x, float y, int flags, long nativePaint, long nativeTypeface)
private static native voidnative_drawText(long nativeCanvas, java.lang.String text, int start, int end, float x, float y, int flags, long nativePaint, long nativeTypeface)
private static native voidnative_drawTextOnPath(long nativeCanvas, char[] text, int index, int count, long nativePath, float hOffset, float vOffset, int bidiFlags, long nativePaint, long nativeTypeface)
private static native voidnative_drawTextOnPath(long nativeCanvas, java.lang.String text, long nativePath, float hOffset, float vOffset, int flags, long nativePaint, long nativeTypeface)
private static native voidnative_drawTextRun(long nativeCanvas, java.lang.String text, int start, int end, int contextStart, int contextEnd, float x, float y, boolean isRtl, long nativePaint, long nativeTypeface)
private static native voidnative_drawTextRun(long nativeCanvas, char[] text, int start, int count, int contextStart, int contextCount, float x, float y, boolean isRtl, long nativePaint, long nativeTypeface)
private static native voidnative_getCTM(long nativeCanvas, long nativeMatrix)
private static native booleannative_getClipBounds(long nativeCanvas, Rect bounds)
private static native intnative_getHeight(long canvasHandle)
private static native intnative_getSaveCount(long canvasHandle)
private static native intnative_getWidth(long canvasHandle)
private static native booleannative_isOpaque(long canvasHandle)
private static native booleannative_quickReject(long nativeCanvas, long nativePath)
private static native booleannative_quickReject(long nativeCanvas, float left, float top, float right, float bottom)
private static native voidnative_restore(long canvasHandle)
private static native voidnative_restoreToCount(long canvasHandle, int saveCount)
private static native voidnative_rotate(long canvasHandle, float degrees)
private static native intnative_save(long canvasHandle, int saveFlags)
private static native intnative_saveLayer(long nativeCanvas, float l, float t, float r, float b, long nativePaint, int layerFlags)
private static native intnative_saveLayerAlpha(long nativeCanvas, float l, float t, float r, float b, int alpha, int layerFlags)
private static native voidnative_scale(long canvasHandle, float sx, float sy)
private static native voidnative_setBitmap(long canvasHandle, long bitmapHandle, boolean copyState)
private static native voidnative_setMatrix(long nativeCanvas, long nativeMatrix)
private static native voidnative_skew(long canvasHandle, float sx, float sy)
private static native voidnative_translate(long canvasHandle, float dx, float dy)
public booleanquickReject(RectF rect, android.graphics.Canvas$EdgeType type)
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).
param
rect the rect to compare with the current clip
param
type {@link Canvas.EdgeType#AA} if the path should be considered antialiased,
since that means it may affect a larger area (more pixels) than
non-antialiased ({@link Canvas.EdgeType#BW}).
return
true if the rect (transformed by the canvas' matrix)
does not intersect with the canvas' clip
        return native_quickReject(mNativeCanvasWrapper,
                rect.left, rect.top, rect.right, rect.bottom);
    
public booleanquickReject(Path path, android.graphics.Canvas$EdgeType type)
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).
param
path The path to compare with the current clip
param
type {@link Canvas.EdgeType#AA} if the path should be considered antialiased,
since that means it may affect a larger area (more pixels) than
non-antialiased ({@link Canvas.EdgeType#BW}).
return
true if the path (transformed by the canvas' matrix)
does not intersect with the canvas' clip
        return native_quickReject(mNativeCanvasWrapper, path.ni());
    
public booleanquickReject(float left, float top, float right, float bottom, android.graphics.Canvas$EdgeType type)
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).
param
left The left side of the rectangle to compare with the
current clip
param
top The top of the rectangle to compare with the current
clip
param
right The right side of the rectangle to compare with the
current clip
param
bottom The bottom of the rectangle to compare with the
current clip
param
type {@link Canvas.EdgeType#AA} if the path should be considered antialiased,
since that means it may affect a larger area (more pixels) than
non-antialiased ({@link Canvas.EdgeType#BW}).
return
true if the rect (transformed by the canvas' matrix)
does not intersect with the canvas' clip
        return native_quickReject(mNativeCanvasWrapper, left, top, right, bottom);
    
public voidrelease()
Releases the resources associated with this canvas.
hide
        mFinalizer.dispose();
    
public voidrestore()
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.
        native_restore(mNativeCanvasWrapper);
    
public voidrestoreToCount(int saveCount)
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().
param
saveCount The save level to restore to.
        native_restoreToCount(mNativeCanvasWrapper, saveCount);
    
public voidrotate(float degrees)
Preconcat the current matrix with the specified rotation.
param
degrees The amount to rotate, in degrees
        native_rotate(mNativeCanvasWrapper, degrees);
    
public final voidrotate(float degrees, float px, float py)
Preconcat the current matrix with the specified rotation.
param
degrees The amount to rotate, in degrees
param
px The x-coord for the pivot point (unchanged by the rotation)
param
py The y-coord for the pivot point (unchanged by the rotation)
        translate(px, py);
        rotate(degrees);
        translate(-px, -py);
    
public intsave()
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.
return
The value to pass to restoreToCount() to balance this save()

                                                                    
       
        return native_save(mNativeCanvasWrapper, MATRIX_SAVE_FLAG | CLIP_SAVE_FLAG);
    
public intsave(int saveFlags)
Based on saveFlags, can save the current matrix and clip onto a private
stack.

Note: if possible, use the
parameter-less save(). It is simpler and faster than individually
disabling the saving of matrix or clip with this method.


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.
param
saveFlags flag bits that specify which parts of the Canvas state
to save/restore
return
The value to pass to restoreToCount() to balance this save()
        return native_save(mNativeCanvasWrapper, saveFlags);
    
public intsaveLayer(RectF bounds, Paint paint, int saveFlags)
This behaves the same as save(), but in addition it allocates and
redirects drawing to an offscreen bitmap.

Note: this method is very expensive,
incurring more than double rendering cost for contained content. Avoid
using this method, especially if the bounds provided are large, or if
the {@link #CLIP_TO_LAYER_SAVE_FLAG} is omitted from the
{@code saveFlags} parameter. It is recommended to use a
{@link android.view.View#LAYER_TYPE_HARDWARE hardware layer} on a View
to apply an xfermode, color filter, or alpha, as it will perform much
better than this method.


All drawing calls are directed to a newly allocated offscreen bitmap.
Only when the balancing call to restore() is made, is that offscreen
buffer drawn back to the current target of the Canvas (either the
screen, it's target Bitmap, or the previous layer).


Attributes of the Paint - {@link Paint#getAlpha() alpha},
{@link Paint#getXfermode() Xfermode}, and
{@link Paint#getColorFilter() ColorFilter} are applied when the
offscreen bitmap is drawn back when restore() is called.
param
bounds May be null. The maximum size the offscreen bitmap
needs to be (in local coordinates)
param
paint This is copied, and is applied to the offscreen when
restore() is called.
param
saveFlags see _SAVE_FLAG constants, generally {@link #ALL_SAVE_FLAG} is recommended
for performance reasons.
return
value to pass to restoreToCount() to balance this save()
        if (bounds == null) {
            bounds = new RectF(getClipBounds());
        }
        return saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, paint, saveFlags);
    
public intsaveLayer(RectF bounds, Paint paint)
Convenience for saveLayer(bounds, paint, {@link #ALL_SAVE_FLAG})
        return saveLayer(bounds, paint, ALL_SAVE_FLAG);
    
public intsaveLayer(float left, float top, float right, float bottom, Paint paint, int saveFlags)
Helper version of saveLayer() that takes 4 values rather than a RectF.
        return native_saveLayer(mNativeCanvasWrapper, left, top, right, bottom,
                paint != null ? paint.mNativePaint : 0,
                saveFlags);
    
public intsaveLayer(float left, float top, float right, float bottom, Paint paint)
Convenience for saveLayer(left, top, right, bottom, paint, {@link #ALL_SAVE_FLAG})
        return saveLayer(left, top, right, bottom, paint, ALL_SAVE_FLAG);
    
public intsaveLayerAlpha(RectF bounds, int alpha, int saveFlags)
This behaves the same as save(), but in addition it allocates and
redirects drawing to an offscreen bitmap.

Note: this method is very expensive,
incurring more than double rendering cost for contained content. Avoid
using this method, especially if the bounds provided are large, or if
the {@link #CLIP_TO_LAYER_SAVE_FLAG} is omitted from the
{@code saveFlags} parameter. It is recommended to use a
{@link android.view.View#LAYER_TYPE_HARDWARE hardware layer} on a View
to apply an xfermode, color filter, or alpha, as it will perform much
better than this method.


All drawing calls are directed to a newly allocated offscreen bitmap.
Only when the balancing call to restore() is made, is that offscreen
buffer drawn back to the current target of the Canvas (either the
screen, it's target Bitmap, or the previous layer).


The {@code alpha} parameter is applied when the offscreen bitmap is
drawn back when restore() is called.
param
bounds The maximum size the offscreen bitmap needs to be
(in local coordinates)
param
alpha The alpha to apply to the offscreen when when it is
drawn during restore()
param
saveFlags see _SAVE_FLAG constants, generally {@link #ALL_SAVE_FLAG} is recommended
for performance reasons.
return
value to pass to restoreToCount() to balance this call
        if (bounds == null) {
            bounds = new RectF(getClipBounds());
        }
        return saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom, alpha, saveFlags);
    
public intsaveLayerAlpha(RectF bounds, int alpha)
Convenience for saveLayerAlpha(bounds, alpha, {@link #ALL_SAVE_FLAG})
        return saveLayerAlpha(bounds, alpha, ALL_SAVE_FLAG);
    
public intsaveLayerAlpha(float left, float top, float right, float bottom, int alpha, int saveFlags)
Helper for saveLayerAlpha() that takes 4 values instead of a RectF.
        alpha = Math.min(255, Math.max(0, alpha));
        return native_saveLayerAlpha(mNativeCanvasWrapper, left, top, right, bottom,
                                     alpha, saveFlags);
    
public intsaveLayerAlpha(float left, float top, float right, float bottom, int alpha)
Helper for saveLayerAlpha(left, top, right, bottom, alpha, {@link #ALL_SAVE_FLAG})
        return saveLayerAlpha(left, top, right, bottom, alpha, ALL_SAVE_FLAG);
    
public voidscale(float sx, float sy)
Preconcat the current matrix with the specified scale.
param
sx The amount to scale in X
param
sy The amount to scale in Y
        native_scale(mNativeCanvasWrapper, sx, sy);
    
public final voidscale(float sx, float sy, float px, float py)
Preconcat the current matrix with the specified scale.
param
sx The amount to scale in X
param
sy The amount to scale in Y
param
px The x-coord for the pivot point (unchanged by the scale)
param
py The y-coord for the pivot point (unchanged by the scale)
        translate(px, py);
        scale(sx, sy);
        translate(-px, -py);
    
public voidsetBitmap(Bitmap bitmap)
Specify a bitmap for the canvas to draw into. All canvas state such as
layers, filters, and the save/restore stack are reset with the exception
of the current matrix and clip stack. Additionally, as a side-effect
the canvas' target density is updated to match that of the bitmap.
param
bitmap Specifies a mutable bitmap for the canvas to draw into.
see
#setDensity(int)
see
#getDensity()
        if (isHardwareAccelerated()) {
            throw new RuntimeException("Can't set a bitmap device on a HW accelerated canvas");
        }

        if (bitmap == null) {
            native_setBitmap(mNativeCanvasWrapper, 0, false);
            mDensity = Bitmap.DENSITY_NONE;
        } else {
            if (!bitmap.isMutable()) {
                throw new IllegalStateException();
            }
            throwIfCannotDraw(bitmap);

            native_setBitmap(mNativeCanvasWrapper, bitmap.ni(), true);
            mDensity = bitmap.mDensity;
        }

        mBitmap = bitmap;
    
public voidsetDensity(int density)
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 {@link Bitmap#setDensity(int) Bitmap.setDensity(int)}.
param
density The new target density of the canvas, which is used
to determine the scaling factor when drawing a bitmap into it. Use
{@link Bitmap#DENSITY_NONE} to disable bitmap scaling.
see
#getDensity()
see
Bitmap#setDensity(int)
        if (mBitmap != null) {
            mBitmap.setDensity(density);
        }
        mDensity = density;
    
public voidsetDrawFilter(DrawFilter filter)
        long nativeFilter = 0;
        if (filter != null) {
            nativeFilter = filter.mNativeInt;
        }
        mDrawFilter = filter;
        nativeSetDrawFilter(mNativeCanvasWrapper, nativeFilter);
    
public voidsetHighContrastText(boolean highContrastText)
hide
public voidsetMatrix(Matrix matrix)
Completely replace the current matrix with the specified matrix. If the
matrix parameter is null, then the current matrix is reset to identity.

Note: it is recommended to use {@link #concat(Matrix)},
{@link #scale(float, float)}, {@link #translate(float, float)} and
{@link #rotate(float)} instead of this method.
param
matrix The matrix to replace the current matrix with. If it is
null, set the current matrix to identity.
see
#concat(Matrix)
        native_setMatrix(mNativeCanvasWrapper,
                         matrix == null ? 0 : matrix.native_instance);
    
private voidsetNativeBitmap(long bitmapHandle)
setBitmap() variant for native callers with a raw bitmap handle.
        native_setBitmap(mNativeCanvasWrapper, bitmapHandle, false);
    
public voidsetScreenDensity(int density)
hide
        mScreenDensity = density;
    
public voidsetViewport(int width, int height)
Set the viewport dimensions if this canvas is GL based. If it is not,
this method is ignored and no exception is thrown.
param
width The width of the viewport
param
height The height of the viewport
hide
public voidskew(float sx, float sy)
Preconcat the current matrix with the specified skew.
param
sx The amount to skew in X
param
sy The amount to skew in Y
        native_skew(mNativeCanvasWrapper, sx, sy);
    
protected static voidthrowIfCannotDraw(Bitmap bitmap)
hide
        if (bitmap.isRecycled()) {
            throw new RuntimeException("Canvas: trying to use a recycled bitmap " + bitmap);
        }
        if (!bitmap.isPremultiplied() && bitmap.getConfig() == Bitmap.Config.ARGB_8888 &&
                bitmap.hasAlpha()) {
            throw new RuntimeException("Canvas: trying to use a non-premultiplied bitmap "
                    + bitmap);
        }
    
public voidtranslate(float dx, float dy)
Preconcat the current matrix with the specified translation
param
dx The distance to translate in X
param
dy The distance to translate in Y
        native_translate(mNativeCanvasWrapper, dx, dy);