DXFCanvas

Nested Classes
Modifier and Type	Class and Description
`static class`	`DXFCanvas.EdgeType`

Fields
Modifier and Type	Field and Description
`static int`	`DIRECTION_LTR` Flag for drawTextRun indicating left-to-right run direction.
`static int`	`DIRECTION_RTL` Flag for drawTextRun indicating right-to-left run direction.
`static int`	`DXF_STROKE_CAP_BUTT` Constants for stroke cap operators
`static int`	`DXF_STROKE_CAP_PROJECTING_SQUARE`
`static int`	`DXF_STROKE_CAP_ROUND`
`static int`	`DXF_STROKE_JOIN_BEVEL`
`static int`	`DXF_STROKE_JOIN_MITER` Constants for stroke join operators
`static int`	`DXF_STROKE_JOIN_ROUND`

Constructors
Constructor and Description
`DXFCanvas(Bitmap bitmap)` Not supported; throws UnsupportedOperationException
`DXFCanvas(DXFDocument dxfDocument)` Construct a canvas for DXF drawing into the specified DXF document.

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`clipPath(Path path)` Intersect the current clip with the specified path.
`boolean`	`clipPath(Path path, Region.Op op)` Not supported; throws UnsupportedOperationException if called.
`boolean`	`clipRect(float left, float top, float right, float bottom)` Intersect the current clip with the specified rectangle, which is expressed in local coordinates.
`boolean`	`clipRect(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.
`boolean`	`clipRect(int left, int top, int right, int bottom)` Intersect the current clip with the specified rectangle, which is expressed in local coordinates.
`boolean`	`clipRect(Rect rect)` Intersect the current clip with the specified rectangle, which is expressed in local coordinates.
`boolean`	`clipRect(RectF rect)` Intersect the current clip with the specified rectangle, which is expressed in local coordinates.
`boolean`	`clipRect(RectF rect, Region.Op op)` Modify the current clip with the specified rectangle.
`boolean`	`clipRect(Rect rect, Region.Op op)` Modify the current clip with the specified rectangle.
`boolean`	`clipRegion(Region region)` Not supported; throws UnsupportedOperationException if called.
`boolean`	`clipRegion(Region region, Region.Op op)` Not supported; throws UnsupportedOperationException if called.
`void`	`concat(Matrix matrix)` Preconcat the current matrix with the specified matrix.
`void`	`drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter, Paint paint)` Draw the specified arc, which will be scaled to fit inside the specified oval.
`void`	`drawARGB(int a, int r, int g, int b)` Fill the entire page (restricted to the current clip) with the specified ARGB color.
`void`	`drawBitmap(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.
`void`	`drawBitmap(Bitmap bitmap, Matrix transformMatrix, Paint paint)` Draw the bitmap using the specified matrix.
`void`	`drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint)` Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle.
`void`	`drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint)` Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle.
`void`	`drawBitmap(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.
`void`	`drawBitmap(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 Unsupported; ignored if called
`void`	`drawBitmapMesh(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.
`void`	`drawCircle(float cx, float cy, float radius, Paint paint)` Draw the specified circle using the specified paint.
`void`	`drawColor(int color)` Fill the entire page (restricted to the current clip) with the specified color.
`void`	`drawColor(int color, PorterDuff.Mode mode)` Fill the entire page (restricted to the current clip) with the specified color and porter-duff xfermode.
`void`	`drawLine(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.
`void`	`drawLines(float[] pts, int offset, int count, Paint paint)` Draw a series of lines.
`void`	`drawLines(float[] pts, Paint paint)` Helper method for drawLines for the common case where all points are to be used.
`void`	`drawOval(RectF oval, Paint paint)` Draw the specified oval using the specified paint.
`void`	`drawPaint(Paint paint)` Fill the entire page (restricted to the current clip) with the specified paint.
`void`	`drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint)` Not supported; throws UnsupportedOperationException if called.
`void`	`drawPath(Path path, Paint paint)` Not supported; throws UnsupportedOperationException if called.
`void`	`drawPicture(Picture picture)` Currently unsupported; throws UnsupportedOperationException if called.
`void`	`drawPicture(Picture picture, Rect dst)` Currently unsupported; throws UnsupportedOperationException if called.
`void`	`drawPicture(Picture picture, RectF dst)` Currently unsupported; throws UnsupportedOperationException if called.
`void`	`drawPoint(float x, float y, Paint paint)` Helper for drawPoints() for drawing a single point.
`void`	`drawPoints(float[] pts, int offset, int count, Paint paint)` Draw a series of points.
`void`	`drawPoints(float[] pts, Paint paint)` Helper for drawPoints() that assumes you want to draw the entire array
`void`	`drawPosText(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, using the typeface and size in the specified Paint.
`void`	`drawPosText(String text, float[] pos, Paint paint)` Draw the text in the array, with each character's origin specified by the pos array, using the typeface and size in the specified Paint.
`void`	`drawRect(float left, float top, float right, float bottom, Paint paint)` Draw the specified Rect using the specified paint.
`void`	`drawRect(RectF r, Paint paint)` Draw the specified Rect using the specified paint.
`void`	`drawRect(Rect r, Paint paint)` Draw the specified Rect using the specified Paint.
`void`	`drawRGB(int r, int g, int b)` Fill the entire page (restricted to the current clip) with the specified RGB color.
`void`	`drawRoundRect(RectF rect, float rx, float ry, Paint paint)` Draw the specified round-rect using the specified paint.
`void`	`drawSpline(int degree, float[] controlPoints, int[] multiplicities, boolean throughEndpoints, Paint paint)` An extension method that supports the drawing of a B-spline.
`void`	`drawText(char[] text, int index, int count, float x, float y, Paint paint)` Draw the text, with origin at (x,y), using the typeface and size in the specified paint.
`void`	`drawText(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), using the typeface and size in the specified paint.
`void`	`drawText(String string, float x, float y, Paint paint)` Draw the text, with origin at (x,y), using the typeface and size in the specified paint.
`void`	`drawText(String text, int start, int end, float x, float y, Paint paint)` Draw the text, with origin at (x,y), using the typeface and size in the specified paint.
`void`	`drawTextOnPath(char[] text, int index, int count, Path path, float hOffset, float vOffset, Paint paint)` Draw the text, with origin at (x,y), along the specified path, using the typeface and size in the specified Paint.
`void`	`drawTextOnPath(String text, Path path, float hOffset, float vOffset, Paint paint)` Draw the text, with origin at (x,y), along the specified path, using the typeface and size in the specified Paint.
`void`	`drawTextRun(char[] text, int index, int count, int contextIndex, int contextCount, float x, float y, int dir, Paint paint)` Currently unsupported; throws UnsupportedOperationException if called.
`void`	`drawTextRun(CharSequence text, int start, int end, int contextStart, int contextEnd, float x, float y, int dir, Paint paint)` Currently unsupported; throws UnsupportedOperationException if called.
`void`	`drawVertices(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).
`boolean`	`getClipBounds(Rect bounds)` Retrieve the clip bounds, returning true if they are non-empty.
`int`	`getDensity()` Returns the target density of the canvas.
`DrawFilter`	`getDrawFilter()` Not supported; throws UnsupportedOperationException if called.
`int`	`getHeight()` Returns the imageable height of the canvas; not relevant here, so set to max integer
`void`	`getMatrix(Matrix ctm)` Return, in ctm, the current transformation matrix.
`int`	`getMaximumBitmapHeight()` Returns the maximum allowed height for bitmaps drawn with this canvas.
`int`	`getMaximumBitmapWidth()` Returns the maximum allowed width for bitmaps drawn with this canvas.
`int`	`getSaveCount()` Returns the number of matrix states on the Canvas' private stack.
`int`	`getWidth()` Returns the imageable width of the canvas; not relevant here, so set to max integer
`boolean`	`isHardwareAccelerated()` Indicates whether this Canvas uses hardware acceleration - DXFCanvas does not.
`boolean`	`isOpaque()` Return true if the device that the current layer draws into is opaque (i.e.
`boolean`	`quickReject(float left, float top, float right, float bottom, DXFCanvas.EdgeType type)` Not supported, so always returns false.
`boolean`	`quickReject(Path path, DXFCanvas.EdgeType type)` Not supported, so always returns false.
`boolean`	`quickReject(RectF rect, DXFCanvas.EdgeType type)` Not supported, so always returns false.
`void`	`restore()` This call balances a previous call to save(), and is used to remove all modifications to the matrix state since the last save call.
`void`	`restoreToCount(int saveCount)` Efficient way to pop any calls to save() that happened after the save count reached saveCount.
`void`	`rotate(float degrees)` Preconcat the current matrix with the specified rotation.
`int`	`save()` Saves the current graphics transformation matrix onto a private stack.
`int`	`save(int saveFlags)` Based on saveFlags, can save the current matrix and clip onto a private stack.
`int`	`saveLayer(float left, float top, float right, float bottom, Paint paint, int saveFlags)` This behaves the same as save(), and all arguments are ignored.
`int`	`saveLayer(RectF bounds, Paint paint, int saveFlags)` This behaves the same as save(), and all arguments are ignored.
`int`	`saveLayerAlpha(float left, float top, float right, float bottom, int alpha, int saveFlags)` This behaves the same as save(), and all arguments are ignored.
`int`	`saveLayerAlpha(RectF bounds, int alpha, int saveFlags)` This behaves the same as save(), and all arguments are ignored.
`void`	`scale(float sx, float sy)` Preconcat the current matrix with the specified scale.
`void`	`setBitmap(Bitmap bitmap)` Not supported; throws UnsupportedOperationException
`void`	`setDensity(int density)` Specifies the density for this Canvas' backing bitmap.
`void`	`setDrawFilter(DrawFilter filter)` Not supported; throws UnsupportedOperationException if called.
`void`	`setMatrix(Matrix matrix)` Completely replace the current matrix with the specified matrix.
`void`	`setScreenDensity(int density)` Not supported; ignored.
`void`	`setViewport(int width, int height)` Set the viewport dimensions if this canvas is GL based.
`void`	`skew(float sx, float sy)` Preconcat the current matrix with the specified skew.
`void`	`translate(float dx, float dy)` Preconcat the current matrix with the specified translation

java.lang.Object
- Canvas
- - com.jsevy.adxf.DXFCanvas

```
public class DXFCanvas
extends Canvas
```
The Android ADXF library provides support for generation of DXF files for use with CAD programs using standard Android "draw" commands. The library provides a special Canvas subclass, DXFCanvas, that is associated with a DXF document and that renders draw commands into DXF syntax. A sequence of Android Canvas drawing method calls will thus create a structured DXF document that, when opened with a standard CAD program, will display the Canvas image as a CAD design that can be modified within the CAD program.
This library is released under the MIT License.
Basic Workflow The class DXFCanvas implements the graphics operations defined by the standard Android Canvas class. To create a DXF drawing, you use the standard Android Canvas drawing calls (including drawing, transformations, etc.) on an instance of DXFCanvas. The DXFCanvas will encode these Android drawing commands as DXF objects in an associated DXFDocument, which can then be saved as a DXF file.
A DXFCanvas is associated with a DXFDocument. The basic workflow is:
```
 // Create a DXF document and get the associated DXFCanvas
 DXFDocument dxfDocument = new DXFDocument("Example");
 DXFCanvas dxfCanvas = dxfDocument.getCanvas();
 
 // Do drawing commands as on any other Canvas
 Paint paint = new Paint();
 paint.setColor(Color.RED);
 paint.setTypeface(Typeface.SERIF);
 paint.setTextSize(38);
 paint.setStyle(Style.STROKE);
 dxfCanvas.drawLine(0, 0,100, 100, paint);
 dxfCanvas.drawRect(120, 180, 400, 400, paint);
 dxfCanvas.drawText("Some text", 200, 600, paint);
 paint.setStyle(Style.FILL);
 dxfCanvas.skew(0.1f, 0.2f);
 dxfCanvas.rotate(-35);
 dxfCanvas.drawCircle(300, 300, 100, paint);
 
 // Write the DXF representation in the document to a file; DXF is just text, so the document generates a String as output
 String dxfText = dxfDocument.toDXFString();
 String filePath = "path/to/file.dxf";
 FileWriter fileWriter = new FileWriter(filePath);
 fileWriter.write(dxfText);
 fileWriter.flush();
 fileWriter.close();
 
```
Features
The APDF library provides most of the drawing operations available in the standard Canvas class. However, certain methods are unimplemented at present (some due to lack of support in DXF). These unimplemented operations will throw an UnsupportedOperationException if used. Some additional features currently have no or limited support, as indicated below.
Supported operations
- Drawing operations, including
  - drawLine
  - drawArc
  - drawCircle
  - drawOval
  - drawRect
  - drawRoundRect
  - drawPoints
  - drawColor
  - drawPaint
- Text operations drawText, drawPosText, drawTextOnPath
- Matrix transformation operations including scale, skew, translate, rotate and concat
- State save and restore
Not supported
- Dotted lines - represented as solid lines
- Underlined and strikethrough text - text represented without underline/strikethrough
- Image drawing through drawBitmap - currently ignored
- Grid and 3D drawing through drawBitmapMesh and drawVertices - currently ignored
- Paint xfermodes - Ignored
- drawPaint, drawColor, drawRGB - currently ignored
- State-save flags and layer information are ignored; save(flags), saveLayer, and saveLayerAlpha all behave the same as plain save()
- quickReject() methods - always return false
- drawTextRun method - throws UnsupportedOperationException
- Clipping, including clipRect, clipRegion, clipPath, etc., methods - throws UnsupportedOperationException
- drawPath method - throws UnsupportedOperationException
- drawPicture method - throws UnsupportedOperationException
- drawPatch method - throws UnsupportedOperationException
Author:

Jon Sevy, jsevy@cs.drexel.edu

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DXFCanvas.EdgeType

Field Summary

Fields
Modifier and Type Field and Description

static int DIRECTION_LTR
Flag for drawTextRun indicating left-to-right run direction.

static int DIRECTION_RTL
Flag for drawTextRun indicating right-to-left run direction.

static int DXF_STROKE_CAP_BUTT
Constants for stroke cap operators

static int DXF_STROKE_CAP_PROJECTING_SQUARE

static int DXF_STROKE_CAP_ROUND

static int DXF_STROKE_JOIN_BEVEL

static int DXF_STROKE_JOIN_MITER
Constants for stroke join operators

static int DXF_STROKE_JOIN_ROUND

Constructor Summary

Constructors
Constructor and Description

DXFCanvas(Bitmap bitmap)
Not supported; throws UnsupportedOperationException

DXFCanvas(DXFDocument dxfDocument)
Construct a canvas for DXF drawing into the specified DXF document.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type Method and Description

boolean clipPath(Path path)
Intersect the current clip with the specified path.

boolean clipPath(Path path, Region.Op op)
Not supported; throws UnsupportedOperationException if called.

boolean clipRect(float left, float top, float right, float bottom)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

boolean clipRect(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.

boolean clipRect(int left, int top, int right, int bottom)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

boolean clipRect(Rect rect)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

boolean clipRect(RectF rect)
Intersect the current clip with the specified rectangle, which is expressed in local coordinates.

boolean clipRect(RectF rect, Region.Op op)
Modify the current clip with the specified rectangle.

boolean clipRect(Rect rect, Region.Op op)
Modify the current clip with the specified rectangle.

boolean clipRegion(Region region)
Not supported; throws UnsupportedOperationException if called.

boolean clipRegion(Region region, Region.Op op)
Not supported; throws UnsupportedOperationException if called.

void concat(Matrix matrix)
Preconcat the current matrix with the specified matrix.

void drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter, Paint paint)
Draw the specified arc, which will be scaled to fit inside the specified oval.

void drawARGB(int a, int r, int g, int b)
Fill the entire page (restricted to the current clip) with the specified ARGB color.

void drawBitmap(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.

void drawBitmap(Bitmap bitmap, Matrix transformMatrix, Paint paint)
Draw the bitmap using the specified matrix.

void drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint)
Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle.

void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint)
Draw the specified bitmap, scaling/translating automatically to fill the destination rectangle.

void drawBitmap(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.

void drawBitmap(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 Unsupported; ignored if called

void drawBitmapMesh(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.

void drawCircle(float cx, float cy, float radius, Paint paint)
Draw the specified circle using the specified paint.

void drawColor(int color)
Fill the entire page (restricted to the current clip) with the specified color.

void drawColor(int color, PorterDuff.Mode mode)
Fill the entire page (restricted to the current clip) with the specified color and porter-duff xfermode.

void drawLine(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.

void drawLines(float[] pts, int offset, int count, Paint paint)
Draw a series of lines.

void drawLines(float[] pts, Paint paint)
Helper method for drawLines for the common case where all points are to be used.

void drawOval(RectF oval, Paint paint)
Draw the specified oval using the specified paint.

void drawPaint(Paint paint)
Fill the entire page (restricted to the current clip) with the specified paint.

void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint)
Not supported; throws UnsupportedOperationException if called.

void drawPath(Path path, Paint paint)
Not supported; throws UnsupportedOperationException if called.

void drawPicture(Picture picture)
Currently unsupported; throws UnsupportedOperationException if called.

void drawPicture(Picture picture, Rect dst)
Currently unsupported; throws UnsupportedOperationException if called.

void drawPicture(Picture picture, RectF dst)
Currently unsupported; throws UnsupportedOperationException if called.

void drawPoint(float x, float y, Paint paint)
Helper for drawPoints() for drawing a single point.

void drawPoints(float[] pts, int offset, int count, Paint paint)
Draw a series of points.

void drawPoints(float[] pts, Paint paint)
Helper for drawPoints() that assumes you want to draw the entire array

void drawPosText(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, using the typeface and size in the specified Paint.

void drawPosText(String text, float[] pos, Paint paint)
Draw the text in the array, with each character's origin specified by the pos array, using the typeface and size in the specified Paint.

void drawRect(float left, float top, float right, float bottom, Paint paint)
Draw the specified Rect using the specified paint.

void drawRect(RectF r, Paint paint)
Draw the specified Rect using the specified paint.

void drawRect(Rect r, Paint paint)
Draw the specified Rect using the specified Paint.

void drawRGB(int r, int g, int b)
Fill the entire page (restricted to the current clip) with the specified RGB color.

void drawRoundRect(RectF rect, float rx, float ry, Paint paint)
Draw the specified round-rect using the specified paint.

void drawSpline(int degree, float[] controlPoints, int[] multiplicities, boolean throughEndpoints, Paint paint)
An extension method that supports the drawing of a B-spline.

void drawText(char[] text, int index, int count, float x, float y, Paint paint)
Draw the text, with origin at (x,y), using the typeface and size in the specified paint.

void drawText(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), using the typeface and size in the specified paint.

void drawText(String string, float x, float y, Paint paint)
Draw the text, with origin at (x,y), using the typeface and size in the specified paint.

void drawText(String text, int start, int end, float x, float y, Paint paint)
Draw the text, with origin at (x,y), using the typeface and size in the specified paint.

void drawTextOnPath(char[] text, int index, int count, Path path, float hOffset, float vOffset, Paint paint)
Draw the text, with origin at (x,y), along the specified path, using the typeface and size in the specified Paint.

void drawTextOnPath(String text, Path path, float hOffset, float vOffset, Paint paint)
Draw the text, with origin at (x,y), along the specified path, using the typeface and size in the specified Paint.

void drawTextRun(char[] text, int index, int count, int contextIndex, int contextCount, float x, float y, int dir, Paint paint)
Currently unsupported; throws UnsupportedOperationException if called.

void drawTextRun(CharSequence text, int start, int end, int contextStart, int contextEnd, float x, float y, int dir, Paint paint)
Currently unsupported; throws UnsupportedOperationException if called.

void drawVertices(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).

boolean getClipBounds(Rect bounds)
Retrieve the clip bounds, returning true if they are non-empty.

int getDensity()
Returns the target density of the canvas.

DrawFilter getDrawFilter()
Not supported; throws UnsupportedOperationException if called.

int getHeight()
Returns the imageable height of the canvas; not relevant here, so set to max integer

void getMatrix(Matrix ctm)
Return, in ctm, the current transformation matrix.

int getMaximumBitmapHeight()
Returns the maximum allowed height for bitmaps drawn with this canvas.

int getMaximumBitmapWidth()
Returns the maximum allowed width for bitmaps drawn with this canvas.

int getSaveCount()
Returns the number of matrix states on the Canvas' private stack.

int getWidth()
Returns the imageable width of the canvas; not relevant here, so set to max integer

boolean isHardwareAccelerated()
Indicates whether this Canvas uses hardware acceleration - DXFCanvas does not.

boolean isOpaque()
Return true if the device that the current layer draws into is opaque (i.e.

boolean quickReject(float left, float top, float right, float bottom, DXFCanvas.EdgeType type)
Not supported, so always returns false.

boolean quickReject(Path path, DXFCanvas.EdgeType type)
Not supported, so always returns false.

boolean quickReject(RectF rect, DXFCanvas.EdgeType type)
Not supported, so always returns false.

void restore()
This call balances a previous call to save(), and is used to remove all modifications to the matrix state since the last save call.

void restoreToCount(int saveCount)
Efficient way to pop any calls to save() that happened after the save count reached saveCount.

void rotate(float degrees)
Preconcat the current matrix with the specified rotation.

int save()
Saves the current graphics transformation matrix onto a private stack.

int save(int saveFlags)
Based on saveFlags, can save the current matrix and clip onto a private stack.

int saveLayer(float left, float top, float right, float bottom, Paint paint, int saveFlags)
This behaves the same as save(), and all arguments are ignored.

int saveLayer(RectF bounds, Paint paint, int saveFlags)
This behaves the same as save(), and all arguments are ignored.

int saveLayerAlpha(float left, float top, float right, float bottom, int alpha, int saveFlags)
This behaves the same as save(), and all arguments are ignored.

int saveLayerAlpha(RectF bounds, int alpha, int saveFlags)
This behaves the same as save(), and all arguments are ignored.

void scale(float sx, float sy)
Preconcat the current matrix with the specified scale.

void setBitmap(Bitmap bitmap)
Not supported; throws UnsupportedOperationException

void setDensity(int density)
Specifies the density for this Canvas' backing bitmap.

void setDrawFilter(DrawFilter filter)
Not supported; throws UnsupportedOperationException if called.

void setMatrix(Matrix matrix)
Completely replace the current matrix with the specified matrix.

void setScreenDensity(int density)
Not supported; ignored.

void setViewport(int width, int height)
Set the viewport dimensions if this canvas is GL based.

void skew(float sx, float sy)
Preconcat the current matrix with the specified skew.

void translate(float dx, float dy)
Preconcat the current matrix with the specified translation

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DXF_STROKE_CAP_BUTT
```
public static final int DXF_STROKE_CAP_BUTT
```
    Constants for stroke cap operators
    
    See Also:
    
    Constant Field Values
  - DXF_STROKE_CAP_ROUND
```
public static final int DXF_STROKE_CAP_ROUND
```
    See Also:
    
    Constant Field Values
  - DXF_STROKE_CAP_PROJECTING_SQUARE
```
public static final int DXF_STROKE_CAP_PROJECTING_SQUARE
```
    See Also:
    
    Constant Field Values
  - DXF_STROKE_JOIN_MITER
```
public static final int DXF_STROKE_JOIN_MITER
```
    Constants for stroke join operators
    
    See Also:
    
    Constant Field Values
  - DXF_STROKE_JOIN_ROUND
```
public static final int DXF_STROKE_JOIN_ROUND
```
    See Also:
    
    Constant Field Values
  - DXF_STROKE_JOIN_BEVEL
```
public static final int DXF_STROKE_JOIN_BEVEL
```
    See Also:
    
    Constant Field Values
  - DIRECTION_LTR
```
public static final int DIRECTION_LTR
```
    Flag for drawTextRun indicating left-to-right run direction.
    
    See Also:
    
    Constant Field Values
  - DIRECTION_RTL
```
public static final int DIRECTION_RTL
```
    Flag for drawTextRun indicating right-to-left run direction.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - DXFCanvas
```
public DXFCanvas(DXFDocument dxfDocument)
```
    Construct a canvas for DXF drawing into the specified DXF document.
    
    Parameters:
    
    dxfDocument - Document into which DXF text representation is generated.
  - DXFCanvas
```
public DXFCanvas(Bitmap bitmap)
```
    Not supported; throws UnsupportedOperationException
- Method Detail
  - isHardwareAccelerated
```
public boolean isHardwareAccelerated()
```
    Indicates whether this Canvas uses hardware acceleration - DXFCanvas does not.
    
    Returns:
    
    Always false
  - setBitmap
```
public void setBitmap(Bitmap bitmap)
```
    Not supported; throws UnsupportedOperationException
  - setViewport
```
public void setViewport(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. Since DXFCanvas is not GL-based, does nothing.
    
    Parameters:
    
    width - The width of the viewport
    
    height - The height of the viewport
  - isOpaque
```
public boolean isOpaque()
```
    Return true if the device that the current layer draws into is opaque (i.e. does not support per-pixel alpha). DXFCanvas only supports opaque layers, so always returns true.
    
    Returns:
    
    Always returns true
  - getWidth
```
public int getWidth()
```
    Returns the imageable width of the canvas; not relevant here, so set to max integer
    
    Returns:
    
    the imageable width of the current canvas
  - getHeight
```
public int getHeight()
```
    Returns the imageable height of the canvas; not relevant here, so set to max integer
    
    Returns:
    
    the imageable height of the current canvas
  - getDensity
```
public int getDensity()
```
    Returns the target density of the canvas.
    
    Returns:
    
    Returns the current target density of the canvas, which is used to determine the scaling factor when drawing a bitmap into it.
    
    See Also:
    
    setDensity(int), Bitmap#getDensity()
  - setDensity
```
public void setDensity(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 Bitmap.setDensity(int).
    
    Parameters:
    
    density - The new target density of the canvas, which is used to determine the scaling factor when drawing a bitmap into it. Use Bitmap#DENSITY_NONE to disable bitmap scaling.
    
    See Also:
    
    getDensity(), Bitmap#setDensity(int)
  - setScreenDensity
```
public void setScreenDensity(int density)
```
    Not supported; ignored.
    
    Parameters:
    
    density -
  - getMaximumBitmapWidth
```
public int getMaximumBitmapWidth()
```
    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 Also:
    
    getMaximumBitmapHeight()
  - getMaximumBitmapHeight
```
public int getMaximumBitmapHeight()
```
    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 Also:
    
    getMaximumBitmapWidth()
  - save
```
public int save()
```
    Saves the current graphics transformation matrix onto a private stack. Subsequent calls to translate,scale,rotate, skew,concat 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.
    
    Returns:
    
    The value to pass to restoreToCount() to balance this save()
  - save
```
public int save(int saveFlags)
```
    Based on saveFlags, can save the current matrix and clip onto a private stack. Subsequent calls to translate, scale, rotate, skew, concat 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. Currently behaves the same as save() - ignores saveFlags and simply saves the entire state.
    
    Parameters:
    
    saveFlags - flag bits that specify which parts of the Canvas state to save/restore - currently ignored
    
    Returns:
    
    The value to pass to restoreToCount() to balance this save()
  - saveLayer
```
public int saveLayer(RectF bounds,
                     Paint paint,
                     int saveFlags)
```
    This behaves the same as save(), and all arguments are ignored.
    
    Parameters:
    
    bounds - Ignored
    
    paint - Ignored
    
    saveFlags - Ignored
    
    Returns:
    
    value to pass to restoreToCount() to balance this save()
  - saveLayer
```
public int saveLayer(float left,
                     float top,
                     float right,
                     float bottom,
                     Paint paint,
                     int saveFlags)
```
    This behaves the same as save(), and all arguments are ignored.
  - saveLayerAlpha
```
public int saveLayerAlpha(RectF bounds,
                          int alpha,
                          int saveFlags)
```
    This behaves the same as save(), and all arguments are ignored.
    
    Parameters:
    
    bounds - Ignored
    
    alpha - Ignored
    
    saveFlags - Ignored
    
    Returns:
    
    value to pass to restoreToCount() to balance this call
  - saveLayerAlpha
```
public int saveLayerAlpha(float left,
                          float top,
                          float right,
                          float bottom,
                          int alpha,
                          int saveFlags)
```
    This behaves the same as save(), and all arguments are ignored.
  - restore
```
public void restore()
```
    This call balances a previous call to save(), and is used to remove all modifications to the matrix state since the last save call. It is an error to call restore() more times than save() was called (throws EmptyStackException).
  - getSaveCount
```
public int getSaveCount()
```
    Returns the number of matrix states on the Canvas' private stack. This will equal # save() calls - # restore() calls.
  - restoreToCount
```
public void restoreToCount(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().
    
    Parameters:
    
    saveCount - The save level to restore to.
  - translate
```
public void translate(float dx,
                      float dy)
```
    Preconcat the current matrix with the specified translation
    
    Parameters:
    
    dx - The distance to translate in X
    
    dy - The distance to translate in Y
  - scale
```
public void scale(float sx,
                  float sy)
```
    Preconcat the current matrix with the specified scale.
    
    Parameters:
    
    sx - The amount to scale in X
    
    sy - The amount to scale in Y
  - rotate
```
public void rotate(float degrees)
```
    Preconcat the current matrix with the specified rotation.
    
    Parameters:
    
    degrees - The amount to rotate, in degrees
  - skew
```
public void skew(float sx,
                 float sy)
```
    Preconcat the current matrix with the specified skew.
    
    Parameters:
    
    sx - The amount to skew in X
    
    sy - The amount to skew in Y
  - concat
```
public void concat(Matrix matrix)
```
    Preconcat the current matrix with the specified matrix.
    
    Parameters:
    
    matrix - The matrix to preconcatenate with the current matrix
  - setMatrix
```
public void setMatrix(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.
    
    Parameters:
    
    matrix - The matrix to replace the current matrix with. If it is null, set the current matrix to identity.
  - getMatrix
```
public void getMatrix(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.
  - clipRect
```
public boolean clipRect(RectF rect,
                        Region.Op op)
```
    Modify the current clip with the specified rectangle. Only supports INTERSECT as the operation; throws an UnsupportedOperationException if another operation is supplied
    
    Parameters:
    
    rect - The rect to intersect with the current clip
    
    op - How the clip is modified
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipRect
```
public boolean clipRect(Rect rect,
                        Region.Op op)
```
    Modify the current clip with the specified rectangle. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    rect - The rectangle to intersect with the current clip.
    
    op - How the clip is modified
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipRect
```
public boolean clipRect(RectF rect)
```
    Intersect the current clip with the specified rectangle, which is expressed in local coordinates. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    rect - The rectangle to intersect with the current clip.
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipRect
```
public boolean clipRect(Rect rect)
```
    Intersect the current clip with the specified rectangle, which is expressed in local coordinates. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    rect - The rectangle to intersect with the current clip.
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipRect
```
public boolean clipRect(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. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    left - The left side of the rectangle to intersect with the current clip
    
    top - The top of the rectangle to intersect with the current clip
    
    right - The right side of the rectangle to intersect with the current clip
    
    bottom - The bottom of the rectangle to intersect with the current clip
    
    op - How the clip is modified
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipRect
```
public boolean clipRect(float left,
                        float top,
                        float right,
                        float bottom)
```
    Intersect the current clip with the specified rectangle, which is expressed in local coordinates. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    left - The left side of the rectangle to intersect with the current clip
    
    top - The top of the rectangle to intersect with the current clip
    
    right - The right side of the rectangle to intersect with the current clip
    
    bottom - The bottom of the rectangle to intersect with the current clip
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipRect
```
public boolean clipRect(int left,
                        int top,
                        int right,
                        int bottom)
```
    Intersect the current clip with the specified rectangle, which is expressed in local coordinates. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    left - The left side of the rectangle to intersect with the current clip
    
    top - The top of the rectangle to intersect with the current clip
    
    right - The right side of the rectangle to intersect with the current clip
    
    bottom - The bottom of the rectangle to intersect with the current clip
    
    Returns:
    
    true if the resulting clip is non-empty
  - clipPath
```
public boolean clipPath(Path path,
                        Region.Op op)
```
    Not supported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    path - The path to operate on the current clip
    
    op - How the clip is modified
    
    Returns:
    
    true if the resulting is non-empty
  - clipPath
```
public boolean clipPath(Path path)
```
    Intersect the current clip with the specified path. Unsupported; throws an UnsupportedOperationException if called
    
    Parameters:
    
    path - The path to intersect with the current clip
    
    Returns:
    
    true if the resulting is non-empty
  - clipRegion
```
public boolean clipRegion(Region region,
                          Region.Op op)
```
    Not supported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    region - The region to operate on the current clip, based on op
    
    op - How the clip is modified
    
    Returns:
    
    true if the resulting is non-empty
  - clipRegion
```
public boolean clipRegion(Region region)
```
    Not supported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    region - The region to operate on the current clip, based on op
    
    Returns:
    
    true if the resulting is non-empty
  - getDrawFilter
```
public DrawFilter getDrawFilter()
```
    Not supported; throws UnsupportedOperationException if called.
  - setDrawFilter
```
public void setDrawFilter(DrawFilter filter)
```
    Not supported; throws UnsupportedOperationException if called.
  - quickReject
```
public boolean quickReject(RectF rect,
                           DXFCanvas.EdgeType type)
```
    Not supported, so always returns false.
    
    Parameters:
    
    rect - Ignored
    
    type - Ignored
    
    Returns:
    
    Always returns false
  - quickReject
```
public boolean quickReject(Path path,
                           DXFCanvas.EdgeType type)
```
    Not supported, so always returns false.
    
    Parameters:
    
    path - Ignored
    
    type - Ignored
    
    Returns:
    
    Always returns false
  - quickReject
```
public boolean quickReject(float left,
                           float top,
                           float right,
                           float bottom,
                           DXFCanvas.EdgeType type)
```
    Not supported, so always returns false.
    
    Parameters:
    
    left - Ignored
    
    top - Ignored
    
    right - Ignored
    
    bottom - Ignored
    
    type - Ignored
    
    Returns:
    
    Always returns false
  - getClipBounds
```
public boolean getClipBounds(Rect bounds)
```
    Retrieve the clip bounds, returning true if they are non-empty. Since clipping not supported, always returns true.
    
    Parameters:
    
    bounds - Return the clip bounds here. If it is null, ignore it but still return true if the current clip is non-empty.
    
    Returns:
    
    true if the current clip is non-empty.
  - drawRGB
```
public void drawRGB(int r,
                    int g,
                    int b)
```
    Fill the entire page (restricted to the current clip) with the specified RGB color. Unsupported; has no effect if called
    
    Parameters:
    
    r - red component (0..255) of the color to draw onto the canvas
    
    g - green component (0..255) of the color to draw onto the canvas
    
    b - blue component (0..255) of the color to draw onto the canvas
  - drawARGB
```
public void drawARGB(int a,
                     int r,
                     int g,
                     int b)
```
    Fill the entire page (restricted to the current clip) with the specified ARGB color. Unsupported; has no effect if called
    
    Parameters:
    
    a - alpha component (0..255) of the color to draw onto the canvas
    
    r - red component (0..255) of the color to draw onto the canvas
    
    g - green component (0..255) of the color to draw onto the canvas
    
    b - blue component (0..255) of the color to draw onto the canvas
  - drawColor
```
public void drawColor(int color)
```
    Fill the entire page (restricted to the current clip) with the specified color. Unsupported; has no effect if called
    
    Parameters:
    
    color - the color to draw onto the canvas
  - drawColor
```
public void drawColor(int color,
                      PorterDuff.Mode mode)
```
    Fill the entire page (restricted to the current clip) with the specified color and porter-duff xfermode. Xfermodes are not currently supported, so always opaque overwrite. Unsupported; has no effect if called
    
    Parameters:
    
    color - the color to draw with
    
    mode - the porter-duff mode to apply to the color - currently ignored
  - drawPaint
```
public void drawPaint(Paint paint)
```
    Fill the entire page (restricted to the current clip) with the specified paint. Unsupported; has no effect if called
    
    Parameters:
    
    paint - The paint used to draw onto the canvas
  - drawPoints
```
public void drawPoints(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).
    
    Parameters:
    
    pts - Array of points to draw [x0 y0 x1 y1 x2 y2 ...]
    
    offset - Number of values to skip before starting to draw.
    
    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).
    
    paint - The paint used to draw the points
  - drawPoints
```
public void drawPoints(float[] pts,
                       Paint paint)
```
    Helper for drawPoints() that assumes you want to draw the entire array
  - drawPoint
```
public void drawPoint(float x,
                      float y,
                      Paint paint)
```
    Helper for drawPoints() for drawing a single point.
  - drawLine
```
public void drawLine(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.
    
    Parameters:
    
    startX - The x-coordinate of the start point of the line
    
    startY - The y-coordinate of the start point of the line
    
    paint - The paint used to draw the line
  - drawLines
```
public void drawLines(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.
    
    Parameters:
    
    pts - Array of points to draw [x0 y0 x1 y1 x2 y2 ...]
    
    offset - Number of values in the array to skip before drawing.
    
    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).
    
    paint - The paint used to draw the points
  - drawLines
```
public void drawLines(float[] pts,
                      Paint paint)
```
    Helper method for drawLines for the common case where all points are to be used.
  - drawRect
```
public void drawRect(RectF 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.
    
    Parameters:
    
    rect - The rect to be drawn
    
    paint - The paint used to draw the rect
  - drawRect
```
public void drawRect(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.
    
    Parameters:
    
    r - The rectangle to be drawn.
    
    paint - The paint used to draw the rectangle
  - drawRect
```
public void drawRect(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.
    
    Parameters:
    
    left - The left side of the rectangle to be drawn
    
    top - The top side of the rectangle to be drawn
    
    right - The right side of the rectangle to be drawn
    
    bottom - The bottom side of the rectangle to be drawn
    
    paint - The paint used to draw the rect
  - drawOval
```
public void drawOval(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.
    
    Parameters:
    
    oval - The rectangle bounds of the oval to be drawn
  - drawCircle
```
public void drawCircle(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.
    
    Parameters:
    
    cx - The x-coordinate of the center of the circle to be drawn
    
    cy - The y-coordinate of the center of the circle to be drawn
    
    radius - The radius of the circle to be drawn
    
    paint - The paint used to draw the circle
  - drawArc
```
public void drawArc(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.)
    
    Parameters:
    
    oval - The bounds of oval used to define the shape and size of the arc
    
    startAngle - Starting angle (in degrees) where the arc begins
    
    sweepAngle - Sweep angle (in degrees) measured clockwise
    
    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
    
    paint - The paint used to draw the arc
  - drawRoundRect
```
public void drawRoundRect(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.
    
    Parameters:
    
    rect - The rectangular bounds of the roundRect to be drawn
    
    rx - The x-radius of the oval used to round the corners
    
    ry - The y-radius of the oval used to round the corners
    
    paint - The paint used to draw the roundRect
  - drawSpline
```
public void drawSpline(int degree,
                       float[] controlPoints,
                       int[] multiplicities,
                       boolean throughEndpoints,
                       Paint paint)
```
    An extension method that supports the drawing of a B-spline. For the common case of a spline that passes through the first and last control points, set the multiplicity of these equal to the spline degree plus 1.
    
    Parameters:
    
    degree - The degree of the spline; must be > 0
    
    controlPoints - The control points that define the shape of the spline, {x1, y1, x2, y2, ..., xn, yn}.
    
    multiplicities - The multiplicities for the control points; the number of multiplicity values must equal the number of control points (i.e., the array size must be half that of the controlPoints array)
    
    throughEndpoints - If true, the spline will be forced to pass through the endpoints by setting the end control point multiplicities to degree + 1
    
    paint - The Paint object used to draw the spline
  - drawPath
```
public void drawPath(Path path,
                     Paint paint)
```
    Not supported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    path - The path to be drawn
    
    paint - The paint used to draw the path
  - drawPatch
```
public void drawPatch(Bitmap bitmap,
                      byte[] chunks,
                      RectF dst,
                      Paint paint)
```
    Not supported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    bitmap - The bitmap to draw as an N-patch
    
    chunks - The patches information (matches the native struct Res_png_9patch)
    
    dst - The destination rectangle.
    
    paint - The paint to draw the bitmap with. may be null
  - drawBitmap
```
public void drawBitmap(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. Unsupported; ignored if called
    
    Parameters:
    
    bitmap - The bitmap to be drawn
    
    left - The position of the left side of the bitmap being drawn
    
    top - The position of the top side of the bitmap being drawn
    
    paint - The paint used to draw the bitmap (may be null)
  - drawBitmap
```
public void drawBitmap(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. Unsupported; ignored if called
    
    Parameters:
    
    bitmap - The bitmap to be drawn
    
    src - May be null. The subset of the bitmap to be drawn
    
    dst - The rectangle that the bitmap will be scaled/translated to fit into
    
    paint - May be null. The paint used to draw the bitmap
  - drawBitmap
```
public void drawBitmap(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. Unsupported; ignored if called
    
    Parameters:
    
    bitmap - The bitmap to be drawn
    
    src - May be null. The subset of the bitmap to be drawn
    
    dst - The rectangle that the bitmap will be scaled/translated to fit into
    
    paint - May be null. The paint used to draw the bitmap
  - drawBitmap
```
public void drawBitmap(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. Unsupported; ignored if called
    
    Parameters:
    
    colors - Array of colors representing the pixels of the bitmap
    
    offset - Offset into the array of colors for the first pixel
    
    stride - The number of colors in the array between rows (must be >= width or <= -width).
    
    x - The X coordinate for where to draw the bitmap
    
    y - The Y coordinate for where to draw the bitmap
    
    width - The width of the bitmap
    
    height - The height of the bitmap
    
    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).
    
    paint - May be null. The paint used to draw the bitmap
  - drawBitmap
```
public void drawBitmap(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 Unsupported; ignored if called
  - drawBitmap
```
public void drawBitmap(Bitmap bitmap,
                       Matrix transformMatrix,
                       Paint paint)
```
    Draw the bitmap using the specified matrix. Unsupported; ignored if called
    
    Parameters:
    
    bitmap - The bitmap to draw
    
    matrix - The matrix used to transform the bitmap when it is drawn
    
    paint - May be null. The paint used to draw the bitmap
  - drawBitmapMesh
```
public void drawBitmapMesh(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. This method stretches the supplied bitmap across the specified mesh, which can be used to create 3D effects in which the bitmap appears to be applied to the surface for which the mesh is the projection on the plane of the page. Unsupported; ignored if called
    
    Parameters:
    
    bitmap - The bitmap to draw using the mesh
    
    meshWidth - The number of columns in the mesh. Nothing is drawn if this is 0
    
    meshHeight - The number of rows in the mesh. Nothing is drawn if this is 0
    
    verts - Array of x,y pairs, specifying where the mesh should be drawn. There must be at least (meshWidth+1) * (meshHeight+1) * 2 + meshOffset values in the array
    
    vertOffset - Number of verts elements to skip before drawing
    
    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.
    
    colorOffset - Number of color elements to skip before drawing
    
    paint - May be null. The paint used to draw the bitmap
  - drawVertices
```
public void drawVertices(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. The color array specifies the color at each vertex, and the colors at each vertex are interpolated across the corresponding triangle in a gradient. The indices and texs arrays are currently ignored.
    The VertexMode determines how the subsequent points in the sequence of vertices are interpreted.
    - TRIANGLES In this mode each triple of points (6 successive coordinates) is treated as a separate triangle. This is the most general mode; no assumption is made about triangle adjacency.
    - TRIANGLE_STRIP In this mode each successive vertex is combined with the two before it to form a new triangle, giving a "strip" of triangles where each shares an edge with the triangle before it
    - TRIANGLE_FAN In this mode the first point is assumed to be the center vertex for all of the triangles, with subsequent points defining the "outer" vertices of the fan arranged radially around the center. The triangles are thus "pie wedges" with the first point at the center of the pie, and each "wedge" sharing an edge and vertex. Note that the first and last outer vertices are not automatically joined.
    Unsupported; ignored if called
    Parameters:
    
    mode - How to interpret the array of vertices
    
    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.
    
    verts - Array of vertices for the mesh
    
    vertOffset - Number of values in the verts to skip before drawing.
    
    texs - Currently ignored (may be null)
    
    texOffset - Currently ignored
    
    colors - Specifies a color for each vertex, to be interpolated across the triangle.
    
    colorOffset - Number of values in colors to skip before drawing.
    
    indices - Currently ignored (may be null)
    
    indexCount - Currently ignored
    
    paint - Currently ignored (may be null)
  - drawText
```
public void drawText(char[] text,
                     int index,
                     int count,
                     float x,
                     float y,
                     Paint paint)
```
    Draw the text, with origin at (x,y), using the typeface and size in the specified paint.
    
    Parameters:
    
    text - The text to be drawn
    
    x - The x-coordinate of the origin of the text being drawn
    
    y - The y-coordinate of the origin of the text being drawn
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawText
```
public void drawText(String string,
                     float x,
                     float y,
                     Paint paint)
```
    Draw the text, with origin at (x,y), using the typeface and size in the specified paint.
    
    Parameters:
    
    string - The text to be drawn
    
    x - The x-coordinate of the origin of the text being drawn
    
    y - The y-coordinate of the origin of the text being drawn
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawText
```
public void drawText(String text,
                     int start,
                     int end,
                     float x,
                     float y,
                     Paint paint)
```
    Draw the text, with origin at (x,y), using the typeface and size in the specified paint.
    
    Parameters:
    
    text - The text to be drawn
    
    start - The index of the first character in text to draw
    
    end - (end - 1) is the index of the last character in text to draw
    
    x - The x-coordinate of the origin of the text being drawn
    
    y - The y-coordinate of the origin of the text being drawn
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawText
```
public void drawText(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), using the typeface and size in the specified paint.
    
    Parameters:
    
    text - The text to be drawn
    
    start - The index of the first character in text to draw
    
    end - (end - 1) is the index of the last character in text to draw
    
    x - The x-coordinate of origin for where to draw the text
    
    y - The y-coordinate of origin for where to draw the text
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawTextRun
```
public void drawTextRun(char[] text,
                        int index,
                        int count,
                        int contextIndex,
                        int contextCount,
                        float x,
                        float y,
                        int dir,
                        Paint paint)
```
    Currently unsupported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    text - the text to render
    
    index - the start of the text to render
    
    count - the count of chars to render
    
    contextIndex - the start of the context for shaping. Must be no greater than index.
    
    contextCount - the number of characters in the context for shaping. ContexIndex + contextCount must be no less than index + count.
    
    x - the x position at which to draw the text
    
    y - the y position at which to draw the text
    
    dir - the run direction, either DIRECTION_LTR or DIRECTION_RTL.
    
    paint - the paint
  - drawTextRun
```
public void drawTextRun(CharSequence text,
                        int start,
                        int end,
                        int contextStart,
                        int contextEnd,
                        float x,
                        float y,
                        int dir,
                        Paint paint)
```
    Currently unsupported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    text - the text to render
    
    start - the start of the text to render. Data before this position can be used for shaping context.
    
    end - the end of the text to render. Data at or after this position can be used for shaping context.
    
    x - the x position at which to draw the text
    
    y - the y position at which to draw the text
    
    dir - the run direction, either 0 for LTR or 1 for RTL.
    
    paint - the paint
  - drawPosText
```
public void drawPosText(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, using the typeface and size in the specified Paint.
    
    Parameters:
    
    text - The text to be drawn
    
    index - The index of the first character to draw
    
    count - The number of characters to draw, starting from index.
    
    pos - Array of [x,y] positions, used to position each character
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawPosText
```
public void drawPosText(String text,
                        float[] pos,
                        Paint paint)
```
    Draw the text in the array, with each character's origin specified by the pos array, using the typeface and size in the specified Paint.
    
    Parameters:
    
    text - The text to be drawn
    
    pos - Array of [x,y] positions, used to position each character
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawTextOnPath
```
public void drawTextOnPath(char[] text,
                           int index,
                           int count,
                           Path path,
                           float hOffset,
                           float vOffset,
                           Paint paint)
```
    Draw the text, with origin at (x,y), along the specified path, using the typeface and size in the specified Paint.
    
    Parameters:
    
    text - The text to be drawn
    
    path - The path the text should follow for its baseline
    
    hOffset - The distance along the path to add to the text's starting position
    
    vOffset - The distance above(-) or below(+) the path to position the text
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawTextOnPath
```
public void drawTextOnPath(String text,
                           Path path,
                           float hOffset,
                           float vOffset,
                           Paint paint)
```
    Draw the text, with origin at (x,y), along the specified path, using the typeface and size in the specified Paint.
    
    Parameters:
    
    text - The text to be drawn
    
    path - The path the text should follow for its baseline
    
    hOffset - The distance along the path to add to the text's starting position
    
    vOffset - The distance above(-) or below(+) the path to position the text
    
    paint - The paint used for the text (e.g. color, size, style)
  - drawPicture
```
public void drawPicture(Picture picture)
```
    Currently unsupported; throws UnsupportedOperationException if called.
    
    Parameters:
    
    picture - The picture to be drawn
  - drawPicture
```
public void drawPicture(Picture picture,
                        RectF dst)
```
    Currently unsupported; throws UnsupportedOperationException if called.
  - drawPicture
```
public void drawPicture(Picture picture,
                        Rect dst)
```
    Currently unsupported; throws UnsupportedOperationException if called.

Class DXFCanvas

Features

Supported operations

Not supported

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DXF_STROKE_CAP_BUTT

DXF_STROKE_CAP_ROUND

DXF_STROKE_CAP_PROJECTING_SQUARE

DXF_STROKE_JOIN_MITER

DXF_STROKE_JOIN_ROUND

DXF_STROKE_JOIN_BEVEL

DIRECTION_LTR

DIRECTION_RTL

Constructor Detail

DXFCanvas

DXFCanvas

Method Detail

isHardwareAccelerated

setBitmap

setViewport

isOpaque

getWidth

getHeight

getDensity

setDensity

setScreenDensity

getMaximumBitmapWidth

getMaximumBitmapHeight

save

save

saveLayer

saveLayer

saveLayerAlpha

saveLayerAlpha

restore

getSaveCount

restoreToCount

translate

scale

rotate

skew

concat

setMatrix

getMatrix

clipRect

clipRect

clipRect

clipRect

clipRect

clipRect

clipRect

clipPath

clipPath

clipRegion

clipRegion

getDrawFilter

setDrawFilter

quickReject

quickReject

quickReject

getClipBounds

drawRGB

drawARGB

drawColor

drawColor

drawPaint

drawPoints

drawPoints

drawPoint

drawLine

drawLines

drawLines

drawRect

drawRect

drawRect