GraphicsContext

java.lang.Object
- ej.microui.display.GraphicsContext

Direct Known Subclasses:

ExplicitFlush
```
public class GraphicsContext
extends java.lang.Object
```
The GraphicsContext class offers basic drawing facilities, to render lines, rectangles, polygons, arcs and text.

GraphicsContext uses 24-bit RGB color. Each color: red, green and blue is defined with an 8-bit value.
Not all displays may support such color depth. Therefore the implementation is in charge of mapping application colors to the most appropriate available colors.

A GraphicsContext object may be used either to
- paint on a display in the "normal" rendering procedure (using paint(GraphicsContext) methods), or
- draw on a mutable image, or
- directly draw on a display bypassing the "normal" rendering mechanism.
When a visible object has to be painted on a Display, the paint method is given a GraphicsContext as argument and should use it to render the visible object.

A GraphicsContext may be requested for a mutable image. This graphics context can be used to draw in the image.

Direct drawing on a display can be done from application by retrieving a GraphicsContext with Display.getNewGraphicsContext() or Display.getNewExplicitFlush(). Using this mechanism does not ensure drawings will be performed before, during or after the current paint(), since it bypasses the serialization system events.

Drawing text relies on available fonts. Text can be drawn using drawChar, drawChars, drawString or drawSubstring. Characters are drawn with the current color of the GraphicsContext object.

The coordinate system is as follows:
- origin is at the upper left corner of the destination.
- X-axis is positive towards the right.
- Y-axis is positive downwards.
A coordinate does not map a pixel, but rather the location between pixels. For instance, the first pixel in the upper left corner matches a square of coordinates: (0,0), (1,0), (1,1) and (0,1). The call (where g is a GraphicsContext) g.fillRect(1,0,2,3) paints six pixels.

Two different stroke styles may be used when drawing lines, arcs or rectangles: either SOLID or DOTTED. Stroke style has no effect on fill, text and image handling.

The SOLID stroke style allows drawing with a one-pixel wide pen. Drawing at a specific coordinate fills the adjacent down-right pixel. For instance, although the next line has a width of 1, g.drawLine(0,0,1,0) draws 2 pixels: the upper-left corner of the display and its adjacent right pixel.

The DOTTED stroke style allows drawing a subset of the pixels that would have been drawn with the SOLID stroke style. Length and frequency of dots is implementation dependent and, as a result, so are the drawn pixels. Note that end of lines or end of arcs, as well as the corner of rectangles may not be drawn with the DOTTED stroke style.

One important remark has to be made about rectangle drawing and filling. Drawing a rectangle with the code:
drawRect(x,y,w,h);
is equivalent to the following code sequence:
drawLine(x,y,x+w,y);
drawLine(x+w,y,x+w,y+h);
drawLine(x+w,y+h,x,y+h);
drawLine(x,y+h,x,y);

In addition, the following code:
fillRect(x,y,w,h);
results in filling rectangle area which differs from the rectangle drawn by drawRect(x,y,w,h). Indeed, the filled area counts w*h pixels, whereas the area delimited by drawRect(x,y,w,h) counts (w+1)*(h+1) pixels.
A filled area must overlap exactly or be contiguous to its matching drawn area. That is to say that there must be no blank space between a filled area and its matching drawn area and that the filled area must not be out of the bounds of the drawn area.

Note that the exact number of pixels drawn by drawLine() and drawArc() are implementation dependent.

A GraphicsContext defines a clipping zone which specifies the destination area that can be modified by calls to the GraphicsContext. The clipping zone can be set by the application but is more commonly set by the UI framework. The clipping zone may be empty (i.e. its size is zero), in that case, every rendering operation will have no effect. It may also be out of the bounds of the destination, in which case every rendering operation out of the range of the destination is ignored. Modification of the coordinate system (with the method translate for instance) has no effect on the clipping zone.

When positioning a visible object (text or image for instance) into a drawable area, a coordinate (x,y) location or anchor point is used. In addition it is possible to express how the object is set around the anchor point. Several constants have been thus defined; they can be combined bit-wise to precisely define how the object is set around the anchor point. For instance,

g.drawString("test",x,y,TOP|LEFT);

draws a string and defines (x,y) as the upper left point of the text zone.

g.drawString("test",x,y,TOP|HCENTER);

will draw string "test" above and centered on (x,y) .

Note that any anchor constants combination must be limited to one of the horizontal constants (LEFT, HCENTER, RIGHT) and one of the vertical constants (TOP, BASELINE for text positioning exclusively, VCENTER, BOTTOM). The default anchor position, obtained with value 0, matches the TOP | LEFT constant combination.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`BASELINE` Constant for positioning the baseline of the text at the anchor point.
`static int`	`BOTTOM` Constant for positioning the bottom of the drawing at the anchor point.
`static int`	`DOTTED` Constant for the `DOTTED` stroke style.
`static int`	`HCENTER` Constant for centering drawing horizontally around the anchor point.
`static int`	`LEFT` Constant for positioning the left side of the drawing at the anchor point.
`static int`	`OPAQUE` Maximal opacity.
`static int`	`RIGHT` Constant for positioning the right side of the drawing at the anchor point.
`static int`	`SOLID` Constant for the `SOLID` stroke style.
`static int`	`TOP` Constant for positioning the top of the drawing at the anchor point.
`static int`	`TRANSPARENT` Minimal opacity.
`static int`	`VCENTER` Constant for centering the drawing vertically around the anchor point.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clipRect(int x, int y, int width, int height)` Sets the clipping area to be the intersection of the specified rectangle with the current clipping rectangle.
`void`	`drawChar(char character, int x, int y, int anchor)` Draws a character using the current font and color. The text anchor point is at position `(x,y)`.
`void`	`drawChars(char[] data, int offset, int length, int x, int y, int anchor)` Draws some characters using the current font and color. The text anchor point is at position `(x,y)`.
`void`	`drawCircle(int x, int y, int diameter)` Draws the outline of a circle covering the rectangle specified by its diameter, using the current color and stroke style.
`void`	`drawCircleArc(int x, int y, int diameter, int startAngle, int arcAngle)` Draws the outline of a circular arc covering the specified square, using the current color and stroke style.
`void`	`drawEllipse(int x, int y, int width, int height)` Draws the outline of a ellipse covering the specified rectangle, using the current color and stroke style.
`void`	`drawEllipseArc(int x, int y, int width, int height, int startAngle, int arcAngle)` Draws the outline of a elliptical arc covering the specified rectangle, using the current color and stroke style.
`void`	`drawHorizontalLine(int x, int y, int width)` Draws an horizontal line from `(x,y)` to `(x+width,y)` using the current color and stroke style.
`void`	`drawImage(Image img, int x, int y, int anchor)` Draws an image at the given anchor point.
`void`	`drawImage(Image img, int x, int y, int anchor, int alpha)` Draws an image at the given anchor point.
`void`	`drawLine(int x1, int y1, int x2, int y2)` Draws a line from `(x1,y1)` to `(x2,y2)` using the current color and stroke style.
`void`	`drawPixel(int x, int y)` Draws a pixel at `(x,y)` using the current color.
`void`	`drawPolygon(int[] xys)` Draws the closed polygon which is defined by the array of integer coordinates, using the current color and stroke style.
`void`	`drawPolygon(int[] xys, int offset, int length)` Draws the closed polygon which is defined by the array of integer coordinates, using the current color and stroke style.
`void`	`drawRect(int x, int y, int width, int height)` Draws the outline of the specified rectangle using the current color and stroke style.
`void`	`drawRegion(Display display, int xSrc, int ySrc, int width, int height, int xDest, int yDest, int anchor)` Draws a region of a display.
`void`	`drawRegion(Display display, int xSrc, int ySrc, int width, int height, int xDest, int yDest, int anchor, int alpha)` Draws a region of a display.
`void`	`drawRegion(Image src, int xSrc, int ySrc, int width, int height, int xDest, int yDest, int anchor)` Draws a region of an image.
`void`	`drawRegion(Image src, int xSrc, int ySrc, int width, int height, int xDest, int yDest, int anchor, int alpha)` Draws a region of an image.
`void`	`drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)` Draws the outline of the specified rounded corner rectangle using the current color and stroke style.
`void`	`drawString(java.lang.String str, int x, int y, int anchor)` Draws the string using the current font and color. The text anchor point is at position `(x,y)`.
`void`	`drawSubstring(java.lang.String str, int offset, int len, int x, int y, int anchor)` Draws the string from `offset` to `offset+length` using the current font and color.
`void`	`drawVerticalLine(int x, int y, int height)` Draws a vertical line from `(x,y)` to `(x,y+height-1)` using the current color and stroke style.
`void`	`fillCircle(int x, int y, int diameter)` Fills a circle covering the rectangle specified by its diameter with the current color.
`void`	`fillCircleArc(int x, int y, int diameter, int startAngle, int arcAngle)` Fills a circular arc covering the specified square with the current color.
`void`	`fillEllipse(int x, int y, int width, int height)` Fills a ellipse covering the specified rectangle with the current color.
`void`	`fillEllipseArc(int x, int y, int width, int height, int startAngle, int arcAngle)` Fills an elliptical arc covering the specified rectangle with the current color.
`void`	`fillPolygon(int[] xys)` Fills the closed polygon which is defined by the array of integer coordinates, using the current color.
`void`	`fillPolygon(int[] xys, int offset, int length)` Fills the closed polygon which is defined by the array of integer coordinates, using the current color.
`void`	`fillRect(int x, int y, int width, int height)` Fills the specified rectangle with the current color.
`void`	`fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)` Fills the specified rounded corner rectangle with the current color.
`static int`	`getAlpha(int opacityPercent)` Gets the alpha level for the given opacity.
`void`	`getARGB(int[] argbData, int offset, int scanlength, int x, int y, int width, int height)` Obtains ARGB pixel data from the specified region of this graphics context and stores it in the provided array of integers.
`int`	`getBackgroundColor()` Gets the current background color.
`int`	`getClipHeight()` Gets the height of the current clipping zone.
`int`	`getClipWidth()` Gets the width of the current clipping zone.
`int`	`getClipX()` Gets the x offset of the current clipping zone, relative to the graphics context's origin.
`int`	`getClipY()` Gets the y offset of the current clipping zone, relative to graphics context's origin.
`int`	`getColor()` Gets the current color: a 24-bits value interpreted as: `0xRRGGBB`, that is, the eight least significant bits give the blue color, the next eight bits the green value and the next eight bits the red color.
`Display`	`getDisplay()` Gets the display associated with the GraphicsContext.
`int`	`getDisplayColor(int color)` Gets the color that will be displayed if the specified color is requested. For example, with a monochrome display, this method will return either 0xFFFFFF (white) or 0x000000 (black) depending on the brightness of the specified color.
`boolean`	`getEllipsis()` Gets whether the truncation mechanism is enabled or not.
`Font`	`getFont()` Gets the current font.
`int`	`getStrokeStyle()` Gets the current stroke style: `SOLID` or `DOTTED`.
`int`	`getTranslateX()` Gets the x coordinate of the translated origin of the graphics context.
`int`	`getTranslateY()` Gets the y coordinate of the translated origin of the graphics context.
`boolean`	`hasBackgroundColor()` Gets whether there us a background color.
`int`	`readPixel(int x, int y)` Obtains the ARGB color of the pixel at `(x,y)`.
`void`	`removeBackgroundColor()` Removes the current background color.
`void`	`setBackgroundColor(int rgbColor)` Sets the current background color. Given value `rgbColor` is interpreted as a 24-bit RGB color, where the eight least significant bits matches the blue component, the next eight more significant bits matches the green component and the next eight more significant bits matches the red component. The background color is used by several drawings: draw text, draw anti-aliased line etc.
`void`	`setClip(int x, int y, int width, int height)` Sets the current clipping zone to the rectangle defined by the given location `(x,y)` and size `(width,height)`.
`void`	`setColor(int rgbColor)` Sets the current color. Given value `rgbColor` is interpreted as a 24-bit RGB color, where the eight least significant bits matches the blue component, the next eight more significant bits matches the green component and the next eight more significant bits matches the red component.
`void`	`setEllipsis(boolean enable)` Enables (disables) truncation when rendering characters.
`void`	`setFont(Font font)` Sets the font for subsequent text operations.
`void`	`setStrokeStyle(int style)` Sets the stroke style of this graphics context.
`void`	`translate(int x, int y)` Translates the `GraphicsContext` origin with the given vector `(x,y)`.

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

- Field Detail
  - HCENTER
```
public static final int HCENTER
```
    Constant for centering drawing horizontally around the anchor point.
    Value 1 is assigned to HCENTER.
    
    See Also:
    
    Constant Field Values
  - VCENTER
```
public static final int VCENTER
```
    Constant for centering the drawing vertically around the anchor point.
    Value 2 is assigned to VCENTER.
    
    See Also:
    
    Constant Field Values
  - LEFT
```
public static final int LEFT
```
    Constant for positioning the left side of the drawing at the anchor point.
    Value 4 is assigned to LEFT.
    
    See Also:
    
    Constant Field Values
  - RIGHT
```
public static final int RIGHT
```
    Constant for positioning the right side of the drawing at the anchor point.
    Value 8 is assigned to RIGHT.
    
    See Also:
    
    Constant Field Values
  - TOP
```
public static final int TOP
```
    Constant for positioning the top of the drawing at the anchor point.
    Value 16 is assigned to TOP.
    
    See Also:
    
    Constant Field Values
  - BOTTOM
```
public static final int BOTTOM
```
    Constant for positioning the bottom of the drawing at the anchor point.
    Value 32 is assigned to BOTTOM.
    
    See Also:
    
    Constant Field Values
  - BASELINE
```
public static final int BASELINE
```
    Constant for positioning the baseline of the text at the anchor point.
    Value 64 is assigned to BASELINE.
    
    See Also:
    
    Constant Field Values
  - SOLID
```
public static final int SOLID
```
    Constant for the SOLID stroke style.
    Value 0 is assigned to SOLID.
    
    See Also:
    
    Constant Field Values
  - DOTTED
```
public static final int DOTTED
```
    Constant for the DOTTED stroke style.
    Value 1 is assigned to DOTTED.
    
    See Also:
    
    Constant Field Values
  - OPAQUE
```
public static final int OPAQUE
```
    Maximal opacity.
    
    Since:
    
    2.0
    
    See Also:
    
    drawImage(Image, int, int, int, int), Constant Field Values
  - TRANSPARENT
```
public static final int TRANSPARENT
```
    Minimal opacity.
    
    Since:
    
    2.0
    
    See Also:
    
    drawImage(Image, int, int, int, int), Constant Field Values
- Method Detail
  - getAlpha
```
public static int getAlpha(int opacityPercent)
```
    Gets the alpha level for the given opacity.
    It can be used to draw transparent images.
    
    Parameters:
    
    opacityPercent - the expected opacity in percentage.
    
    Returns:
    
    the alpha level.
    
    Since:
    
    2.0
    
    See Also:
    
    drawImage(Image, int, int, int, int)
  - translate
```
public final void translate(int x,
                            int y)
```
    Translates the GraphicsContext origin with the given vector (x,y). Subsequent rendering operations on the graphics context will be relative to the new origin.
    This method can be used to set an absolute origin to a GraphicsContext. For instance, the following code:
    g.translate(ax-g.getTranslateX(),ay-g.getTranslateY());
    will set the origin of g at (ax,ay).
    
    Parameters:
    
    x - the translation for the x coordinate.
    
    y - the translation for the y coordinate.
  - getTranslateX
```
public final int getTranslateX()
```
    Gets the x coordinate of the translated origin of the graphics context.
    
    Returns:
    
    x coordinate of the translated origin.
  - getTranslateY
```
public final int getTranslateY()
```
    Gets the y coordinate of the translated origin of the graphics context.
    
    Returns:
    
    y coordinate of the translated origin.
  - setColor
```
public final void setColor(int rgbColor)
```
    Sets the current color.
    Given value rgbColor is interpreted as a 24-bit RGB color, where the eight least significant bits matches the blue component, the next eight more significant bits matches the green component and the next eight more significant bits matches the red component.
    
    Parameters:
    
    rgbColor - the color to set.
  - setBackgroundColor
```
public final void setBackgroundColor(int rgbColor)
```
    Sets the current background color.
    Given value rgbColor is interpreted as a 24-bit RGB color, where the eight least significant bits matches the blue component, the next eight more significant bits matches the green component and the next eight more significant bits matches the red component.
    The background color is used by several drawings: draw text, draw anti-aliased line etc. When not set, these algorithms have to read the pixel destination color before blending it with the current foreground color.
    Note: this background color is useless for black and white displays.
    
    Parameters:
    
    rgbColor - the color to set.
  - removeBackgroundColor
```
public final void removeBackgroundColor()
```
    Removes the current background color.
  - getColor
```
public final int getColor()
```
    Gets the current color: a 24-bits value interpreted as: 0xRRGGBB, that is, the eight least significant bits give the blue color, the next eight bits the green value and the next eight bits the red color.
    
    Returns:
    
    the current color.
  - getBackgroundColor
```
public final int getBackgroundColor()
```
    Gets the current background color.
    
    Returns:
    
    the current background color.
  - hasBackgroundColor
```
public final boolean hasBackgroundColor()
```
    Gets whether there us a background color.
    
    Returns:
    
    true if there is a background color, false otherwise.
  - getDisplayColor
```
public final int getDisplayColor(int color)
```
    Gets the color that will be displayed if the specified color is requested.
    For example, with a monochrome display, this method will return either 0xFFFFFF (white) or 0x000000 (black) depending on the brightness of the specified color.
    
    Parameters:
    
    color - the desired color in 0x00RRGGBB format.
    
    Returns:
    
    the corresponding color that will be displayed on the graphics context (in 0x00RRGGBB format).
  - setStrokeStyle
```
public final void setStrokeStyle(int style)
```
    Sets the stroke style of this graphics context. It is used to draw lines, arcs, circle, rectangles and polygons.
    
    Parameters:
    
    style - either SOLID or DOTTED.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the style is not valid.
  - getStrokeStyle
```
public final int getStrokeStyle()
```
    Gets the current stroke style: SOLID or DOTTED.
    
    Returns:
    
    the stroke style.
  - setFont
```
public void setFont(Font font)
```
    Sets the font for subsequent text operations. If given font is null, the GraphicsContext's font is set to DisplayFont.getDefaultFont().
    
    Parameters:
    
    font - the new font to use.
  - getFont
```
public final Font getFont()
```
    Gets the current font.
    
    Returns:
    
    the current font.
  - clipRect
```
public final void clipRect(int x,
                           int y,
                           int width,
                           int height)
```
    Sets the clipping area to be the intersection of the specified rectangle with the current clipping rectangle. It is legal to specify a clip rectangle whose width or height is zero or negative. In this case the clip is considered to be empty, that is, no pixels are contained within it. Therefore, if any graphics operations are issued under such a clip, no pixels will be modified.
    
    Parameters:
    
    x - the x coordinate of the rectangle.
    
    y - the y coordinate of the rectangle.
    
    width - the width of the rectangle.
    
    height - the height of the rectangle.
  - setClip
```
public final void setClip(int x,
                          int y,
                          int width,
                          int height)
```
    Sets the current clipping zone to the rectangle defined by the given location (x,y) and size (width,height). Given width or height may be zero or negative, in that case the clip is considered to be empty, i.e. it contains no pixels. Nothing is done when drawing in an empty clip. Rendering operations have no effect outside of the clipping area.
    
    Parameters:
    
    x - the x coordinate of the new clip rectangle.
    
    y - the y coordinate of the new clip rectangle.
    
    width - the width of the new clip rectangle.
    
    height - the height of the new clip rectangle.
  - getClipX
```
public final int getClipX()
```
    Gets the x offset of the current clipping zone, relative to the graphics context's origin.
    
    Returns:
    
    the x offset of the current clipping zone.
  - getClipY
```
public final int getClipY()
```
    Gets the y offset of the current clipping zone, relative to graphics context's origin.
    
    Returns:
    
    the y offset of the current clipping zone.
  - getClipWidth
```
public final int getClipWidth()
```
    Gets the width of the current clipping zone.
    
    Returns:
    
    the width of the current clipping zone.
  - getClipHeight
```
public final int getClipHeight()
```
    Gets the height of the current clipping zone.
    
    Returns:
    
    the height of the current clipping zone.
  - drawPixel
```
public final void drawPixel(int x,
                            int y)
```
    Draws a pixel at (x,y) using the current color.
    
    Parameters:
    
    x - the x coordinate of the pixel.
    
    y - the y coordinate of the pixel.
  - readPixel
```
public final int readPixel(int x,
                           int y)
```
    Obtains the ARGB color of the pixel at (x,y). The read color may be different than the drawing color. It is screen dependent, according to the number of bits per pixels (see Display.getBPP()).
    
    Parameters:
    
    x - the x coordinate of the pixel.
    
    y - the y coordinate of the pixel.
    
    Returns:
    
    the ARGB color of the pixel.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the pixel coordinates are out of bounds of the source graphics context.
  - drawHorizontalLine
```
public final void drawHorizontalLine(int x,
                                     int y,
                                     int width)
```
    Draws an horizontal line from (x,y) to (x+width,y) using the current color and stroke style. The drawn line counts (width+1) pixels.
    If width is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the start of the line.
    
    y - the y coordinate of the start of the line.
    
    width - the width of the horizontal line to draw.
  - drawVerticalLine
```
public final void drawVerticalLine(int x,
                                   int y,
                                   int height)
```
    Draws a vertical line from (x,y) to (x,y+height-1) using the current color and stroke style. The drawn line counts (height+1) pixels.
    If height is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the start of the line.
    
    y - the y coordinate of the start of the line.
    
    height - the width of the vertical line to draw.
  - drawLine
```
public final void drawLine(int x1,
                           int y1,
                           int x2,
                           int y2)
```
    Draws a line from (x1,y1) to (x2,y2) using the current color and stroke style.
    
    Parameters:
    
    x1 - the x coordinate of the start of the line.
    
    y1 - the y coordinate of the start of the line.
    
    x2 - the x coordinate of the end of the line.
    
    y2 - the y coordinate of the end of the line.
  - drawRect
```
public final void drawRect(int x,
                           int y,
                           int width,
                           int height)
```
    Draws the outline of the specified rectangle using the current color and stroke style. The drawn rectangle includes (width+1)*(height+1) pixels.
    If either width or height is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the rectangle to draw.
    
    y - the y coordinate of the rectangle to draw.
    
    width - the width of the rectangle to draw.
    
    height - the height of the rectangle to draw.
  - fillRect
```
public final void fillRect(int x,
                           int y,
                           int width,
                           int height)
```
    Fills the specified rectangle with the current color. If either width or height is negative or zero, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the rectangle to be filled.
    
    y - the y coordinate of the rectangle to be filled.
    
    width - the width of the rectangle to be filled.
    
    height - the height of the rectangle to be filled.
  - drawRoundRect
```
public final void drawRoundRect(int x,
                                int y,
                                int width,
                                int height,
                                int arcWidth,
                                int arcHeight)
```
    Draws the outline of the specified rounded corner rectangle using the current color and stroke style. Drawn rectangle is width+1 -pixel wide and height+1-pixel high. If either width or height is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the rectangle to draw.
    
    y - the y coordinate of the rectangle to draw.
    
    width - the width of the rectangle to draw.
    
    height - the height of the rectangle to draw.
    
    arcWidth - the horizontal diameter of the arc at the corners.
    
    arcHeight - the vertical diameter of the arc at the corners.
  - fillRoundRect
```
public final void fillRoundRect(int x,
                                int y,
                                int width,
                                int height,
                                int arcWidth,
                                int arcHeight)
```
    Fills the specified rounded corner rectangle with the current color. If either width or height is negative or zero, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the rectangle to fill.
    
    y - the y coordinate of the rectangle to fill.
    
    width - the width of the rectangle to fill.
    
    height - the height of the rectangle to fill.
    
    arcWidth - the horizontal diameter of the arc at the corners.
    
    arcHeight - the vertical diameter of the arc at the corners.
  - drawPolygon
```
public final void drawPolygon(int[] xys)
```
    Draws the closed polygon which is defined by the array of integer coordinates, using the current color and stroke style. Lines are drawn between each consecutive pair, and between the first pair and last pair in the array.
    
    Parameters:
    
    xys - the array of coordinates : x1,y1,......xn,yn.
    
    Throws:
    
    java.lang.NullPointerException - if the given array is null.
    
    java.lang.IllegalArgumentException - if the given array length is odd.
  - drawPolygon
```
public final void drawPolygon(int[] xys,
                              int offset,
                              int length)
```
    Draws the closed polygon which is defined by the array of integer coordinates, using the current color and stroke style. Lines are drawn between each consecutive pair, and between the first pair and last pair in the array.
    
    Parameters:
    
    xys - the array of coordinates : x1,y1,......xn,yn.
    
    offset - the x1 index in xys.
    
    length - the number of coordinates, must be even.
    
    Throws:
    
    java.lang.NullPointerException - if the given array is null.
    
    java.lang.IllegalArgumentException - if the given array length is odd.
    
    java.lang.ArrayIndexOutOfBoundsException - the wanted data is outside the array bounds.
  - fillPolygon
```
public final void fillPolygon(int[] xys)
```
    Fills the closed polygon which is defined by the array of integer coordinates, using the current color. Lines are drawn between each consecutive pair, and between the first pair and last pair in the array. The lines connecting each pair of points are included in the filled polygon. The effect is identical to
    fillPolygon(xys,0,xys.length);
    
    Parameters:
    
    xys - the array of coordinates : x1,y1,......xn,yn.
    
    Throws:
    
    java.lang.NullPointerException - if the given array is null.
    
    java.lang.IllegalArgumentException - if the given array length is odd.
  - fillPolygon
```
public final void fillPolygon(int[] xys,
                              int offset,
                              int length)
```
    Fills the closed polygon which is defined by the array of integer coordinates, using the current color. Lines are drawn between each consecutive pair, and between the first pair and last pair in the array. The lines connecting each pair of points are included in the filled polygon. The effect is identical to
    fillPolygon(xys,0,xys.length);
    
    Parameters:
    
    xys - the array of coordinates : x1,y1,......xn,yn.
    
    offset - the x1 index in xys.
    
    length - the number of coordinates, must be even.
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if offset and length do not specify a valid range within xys.
    
    java.lang.NullPointerException - if the xys array is null.
    
    java.lang.IllegalArgumentException - if the xys length is odd.
  - drawCircleArc
```
public final void drawCircleArc(int x,
                                int y,
                                int diameter,
                                int startAngle,
                                int arcAngle)
```
    Draws the outline of a circular arc covering the specified square, using the current color and stroke style.
    The arc is drawn from startAngle up to arcAngle degrees. The center of the arc is defined as the center of the rectangle whose origin is at (x,y) (upper-left corner) and whose dimension is given by diameter.
    Angles are interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a counter-clockwise rotation while a negative value indicates a clockwise rotation.
    If the given diameter is negative, nothing is drawn.
    The angles are given relative to the rectangle. For instance an angle of 45 degrees is always defined by the line from the center of the rectangle to the upper right corner of the rectangle. Thus for a non squarred rectangle angles are skewed along either height or width.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the arc is drawn
    
    y - the y coordinate of the upper-left corner of the rectangle where the arc is drawn
    
    diameter - the diameter of the arc to draw
    
    startAngle - the beginning angle of the arc to draw
    
    arcAngle - the angular extent of the arc from startAngle
  - drawEllipseArc
```
public final void drawEllipseArc(int x,
                                 int y,
                                 int width,
                                 int height,
                                 int startAngle,
                                 int arcAngle)
```
    Draws the outline of a elliptical arc covering the specified rectangle, using the current color and stroke style.
    The arc is drawn from startAngle up to arcAngle degrees. The center of the arc is defined as the center of the rectangle whose origin is at (x,y) (upper-left corner) and whose dimension is given by width and height.
    Angles are interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a counter-clockwise rotation while a negative value indicates a clockwise rotation.
    If either the given width or height is negative, nothing is drawn.
    The angles are given relative to the rectangle. For instance an angle of 45 degrees is always defined by the line from the center of the rectangle to the upper right corner of the rectangle. Thus for a non squarred rectangle angles are skewed along either height or width.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the arc is drawn
    
    y - the y coordinate of the upper-left corner of the rectangle where the arc is drawn
    
    width - the width of the arc to draw
    
    height - the height of the arc to draw
    
    startAngle - the beginning angle of the arc to draw
    
    arcAngle - the angular extent of the arc from startAngle
  - fillCircleArc
```
public final void fillCircleArc(int x,
                                int y,
                                int diameter,
                                int startAngle,
                                int arcAngle)
```
    Fills a circular arc covering the specified square with the current color.
    The arc is drawn from startAngle up to arcAngle degrees. The center of the arc is defined as the center of the rectangle whose origin is at (x,y) (upper-left corner) and whose dimension is given by diameter.
    Angles are interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a counter-clockwise rotation while a negative value indicates a clockwise rotation.
    This method fills the area bounded from the center of the arc to the arc itself.
    If the given diameter is negative, nothing is drawn.
    The angles are given relatively to the rectangle. That is to say that the angle of 45 degrees is always defined by the line from the center of the rectangle to the upper-right corner of the rectangle. Thus for a non squarred rectangle angles are skewed along either height or width.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the arc is filled.
    
    y - the y coordinate of the upper-left corner of the rectangle where the arc is filled.
    
    diameter - the diameter of the arc to fill
    
    startAngle - the beginning angle of the arc to draw
    
    arcAngle - the angular extent of the arc from startAngle
  - fillEllipseArc
```
public final void fillEllipseArc(int x,
                                 int y,
                                 int width,
                                 int height,
                                 int startAngle,
                                 int arcAngle)
```
    Fills an elliptical arc covering the specified rectangle with the current color.
    The arc is drawn from startAngle up to arcAngle degrees. The center of the arc is defined as the center of the rectangle whose origin is at (x,y) (upper-left corner) and whose dimension is given by width and height.
    Angles are interpreted such that 0 degrees is at the 3 o'clock position. A positive value indicates a counter-clockwise rotation while a negative value indicates a clockwise rotation.
    This method fills the area bounded from the center of the arc to the arc itself.
    If either the given width or height is negative, nothing is drawn.
    The angles are given relatively to the rectangle. That is to say that the angle of 45 degrees is always defined by the line from the center of the rectangle to the upper-right corner of the rectangle. Thus for a non squared rectangle angles are skewed along either height or width.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the arc is filled.
    
    y - the y coordinate of the upper-left corner of the rectangle where the arc is filled.
    
    width - the width of the arc to fill.
    
    height - the height of the arc to fill.
    
    startAngle - the beginning angle of the arc to draw.
    
    arcAngle - the angular extent of the arc from the given start angle.
  - drawCircle
```
public final void drawCircle(int x,
                             int y,
                             int diameter)
```
    Draws the outline of a circle covering the rectangle specified by its diameter, using the current color and stroke style.
    The center of the circle is defined as the center of the rectangle whose origin is at the given coordinates (upper-left corner) and whose dimension is given by the diameter parameter.
    If the given diameter is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the circle is drawn.
    
    y - the y coordinate of the upper-left corner of the rectangle where the circle is drawn.
    
    diameter - the diameter of the circle to draw.
  - fillCircle
```
public final void fillCircle(int x,
                             int y,
                             int diameter)
```
    Fills a circle covering the rectangle specified by its diameter with the current color.
    The center of the circle is defined as the center of the rectangle whose origin is at the given coordinates (upper-left corner) and whose dimension is given by the diameter parameter.
    If the given diameter is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the circle is filled.
    
    y - the y coordinate of the upper-left corner of the rectangle where the circle is filled.
    
    diameter - the diameter of the circle to fill.
  - drawEllipse
```
public final void drawEllipse(int x,
                              int y,
                              int width,
                              int height)
```
    Draws the outline of a ellipse covering the specified rectangle, using the current color and stroke style.
    The center of the ellipse is defined as the center of the rectangle whose origin is at the given coordinates (upper-left corner) and whose dimension is given by the width and height parameters.
    If either the given width or height is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the ellipse is drawn.
    
    y - the y coordinate of the upper-left corner of the rectangle where the ellipse is drawn.
    
    width - the width of the ellipse to draw.
    
    height - the height of the ellipse to draw.
  - fillEllipse
```
public final void fillEllipse(int x,
                              int y,
                              int width,
                              int height)
```
    Fills a ellipse covering the specified rectangle with the current color.
    The center of the ellipse is defined as the center of the rectangle whose origin is at the given coordinates (upper-left corner) and whose dimension is given by the width and height parameters.
    If either the given width or height is negative, nothing is drawn.
    
    Parameters:
    
    x - the x coordinate of the upper-left corner of the rectangle where the ellipse is filled.
    
    y - the y coordinate of the upper-left corner of the rectangle where the ellipse is filled.
    
    width - the width of the ellipse to fill.
    
    height - the height of the ellipse to fill.
  - drawImage
```
public final void drawImage(Image img,
                            int x,
                            int y,
                            int anchor)
```
    Draws an image at the given anchor point.
    The image anchor point is at the given position. Position constants may be given to specify the precise location of the image around the anchor point.
    Equivalent to calling drawImage(Image, int, int, int, int) with OPAQUE as alpha.
    
    Parameters:
    
    img - the image to draw.
    
    x - the x coordinate of the anchor point.
    
    y - the y coordinate of the anchor point.
    
    anchor - position of the image around the anchor point.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value (BASELINE is illegal).
    
    java.lang.NullPointerException - if the given image is null.
  - drawImage
```
public final void drawImage(Image img,
                            int x,
                            int y,
                            int anchor,
                            int alpha)
```
    Draws an image at the given anchor point. In addition with drawImage(Image, int, int, int), this method allows to specify the global opacity value to apply during the image rendering.
    
    Parameters:
    
    img - the image to draw.
    
    x - the x coordinate of the anchor point.
    
    y - the y coordinate of the anchor point.
    
    anchor - position of the image around the anchor point.
    
    alpha - the global opacity rendering value.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value (BASELINE is illegal).
    
    java.lang.IllegalArgumentException - if the given alpha is not a value between TRANSPARENT and OPAQUE.
    
    java.lang.NullPointerException - if the given image is null.
    
    Since:
    
    2.0
  - drawRegion
```
public final void drawRegion(Image src,
                             int xSrc,
                             int ySrc,
                             int width,
                             int height,
                             int xDest,
                             int yDest,
                             int anchor)
```
    Draws a region of an image.
    Equivalent to calling drawRegion(Image, int, int, int, int, int, int, int, int) with OPAQUE as alpha.
    
    Parameters:
    
    src - the image to copy from.
    
    xSrc - the x coordinate of the upper-left corner of the region to copy.
    
    ySrc - the y coordinate of the upper-left corner of the region to copy.
    
    width - the width of the region to copy.
    
    height - the height of the region to copy.
    
    xDest - the x coordinate of the anchor point in the destination.
    
    yDest - the y coordinate of the anchor point in the destination.
    
    anchor - the position of the region around the anchor point.
    
    Throws:
    
    java.lang.NullPointerException - if the given image is null.
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value (BASELINE is illegal).
  - drawRegion
```
public final void drawRegion(Image src,
                             int xSrc,
                             int ySrc,
                             int width,
                             int height,
                             int xDest,
                             int yDest,
                             int anchor,
                             int alpha)
```
    Draws a region of an image.
    The region of the image to draw is given relative to the image (origin at the upper-left corner) as a rectangle.
    The image region anchor point in destination is at the given relative position. Position constants may be given to specify the precise location of the image around the anchor point.
    If the specified source region exceeds the image bounds, the copied region is limited to the image boundary. If the copied region goes out of the bounds of the graphics context area, pixels out of the range will not be drawn.
    This method allows to specify the opacity value to apply during the image rendering.
    
    Parameters:
    
    src - the image to copy from.
    
    xSrc - the x coordinate of the upper-left corner of the region to copy.
    
    ySrc - the y coordinate of the upper-left corner of the region to copy.
    
    width - the width of the region to copy.
    
    height - the height of the region to copy.
    
    xDest - the x coordinate of the anchor point in the destination.
    
    yDest - the y coordinate of the anchor point in the destination.
    
    anchor - the position of the region around the anchor point.
    
    alpha - the alpha to apply to the region.
    
    Throws:
    
    java.lang.NullPointerException - if the given image is null.
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value (BASELINE is illegal).
    
    java.lang.IllegalArgumentException - if the given alpha is not a value between TRANSPARENT and OPAQUE.
    
    Since:
    
    2.0
  - drawRegion
```
public void drawRegion(Display display,
                       int xSrc,
                       int ySrc,
                       int width,
                       int height,
                       int xDest,
                       int yDest,
                       int anchor)
```
    Draws a region of a display.
    Equivalent to calling drawRegion(Display, int, int, int, int, int, int, int, int) with OPAQUE as alpha.
    
    Parameters:
    
    display - the display to copy from.
    
    xSrc - the x coordinate of the upper-left corner of the region to copy.
    
    ySrc - the y coordinate of the upper-left corner of the region to copy.
    
    width - the width of the region to copy.
    
    height - the height of the region to copy.
    
    xDest - the x coordinate of the anchor point in the destination.
    
    yDest - the y coordinate of the anchor point in the destination.
    
    anchor - the position of the region around the anchor point.
    
    Throws:
    
    java.lang.NullPointerException - if the given display is null.
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value (BASELINE is illegal).
    
    See Also:
    
    Display.getScreenshot(), Display.getScreenshot(int, int, int, int)
  - drawRegion
```
public void drawRegion(Display display,
                       int xSrc,
                       int ySrc,
                       int width,
                       int height,
                       int xDest,
                       int yDest,
                       int anchor,
                       int alpha)
```
    Draws a region of a display.
    The region of the display to draw is given relative to the display (origin at the upper-left corner) as a rectangle.
    If the specified source region exceeds the image bounds, the copied region is limited to the image boundary. If the copied region goes out of the bounds of the graphics context area, pixels out of the range will not be drawn.
    This method allows to specify the opacity value to apply during the display content rendering.
    
    Parameters:
    
    display - the display to copy from.
    
    xSrc - the x coordinate of the upper-left corner of the region to copy.
    
    ySrc - the y coordinate of the upper-left corner of the region to copy.
    
    width - the width of the region to copy.
    
    height - the height of the region to copy.
    
    xDest - the x coordinate of the anchor point in the destination.
    
    yDest - the y coordinate of the anchor point in the destination.
    
    anchor - the position of the region around the anchor point.
    
    alpha - the alpha to apply to the region.
    
    Throws:
    
    java.lang.NullPointerException - if the given display is null.
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value (BASELINE is illegal).
    
    java.lang.IllegalArgumentException - if the given alpha is not a value between TRANSPARENT and OPAQUE.
    
    Since:
    
    2.0
    
    See Also:
    
    Display.getScreenshot(), Display.getScreenshot(int, int, int, int)
  - getARGB
```
public final void getARGB(int[] argbData,
                          int offset,
                          int scanlength,
                          int x,
                          int y,
                          int width,
                          int height)
```
    Obtains ARGB pixel data from the specified region of this graphics context and stores it in the provided array of integers. Each pixel value is stored in @{code 0xAARRGGBB} format, where the high-order byte contains the alpha channel and the remaining bytes contain color components for red, green and blue, respectively. The alpha channel specifies the opacity of the pixel, where a value of @{code 0x00} represents a pixel that is fully transparent and a value of @{code 0xFF} represents a fully opaque pixel.
    Color values may be resampled to reflect the display capabilities of the device (for example, red, green or blue pixels may all be represented by the same gray value on a grayscale device).
    The scan length specifies the relative offset within the array between the corresponding pixels of consecutive rows. In order to prevent rows of stored pixels from overlapping, the absolute value of scan length must be greater than or equal to the given width. Negative values of scan length are allowed. In all cases, this must result in every reference being within the bounds of the ARGB pixel data array.
    
    Parameters:
    
    argbData - an array of integers in which the ARGB pixel data is stored.
    
    offset - the index into the array where the first ARGB value is stored.
    
    scanlength - the relative offset in the array between corresponding pixels in consecutive rows of the region.
    
    x - the x-coordinate of the upper left corner of the region.
    
    y - the y-coordinate of the upper left corner of the region.
    
    width - the width of the region.
    
    height - the height of the region.
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the requested operation would attempt to access an element in the given ARGB pixel data array whose index is either negative or beyond its length (the contents of the array are unchanged).
    
    java.lang.IllegalArgumentException - if the area being retrieved exceeds the bounds of the source graphics context.
    
    java.lang.IllegalArgumentException - if the absolute value of the given scan length is less than the given width.
    
    java.lang.NullPointerException - if the given ARGB pixel data is @{code null}.
  - drawString
```
public final void drawString(java.lang.String str,
                             int x,
                             int y,
                             int anchor)
```
    Draws the string using the current font and color.
    The text anchor point is at position (x,y). Position constants may be given to specify the precise location of the text around the anchor point.
    See GraphicsContext for details of anchors.
    
    Parameters:
    
    str - the string to draw.
    
    x - the x coordinate of the anchor point.
    
    y - the y coordinate of the anchor point.
    
    anchor - position of the text around the anchor point.
    
    Throws:
    
    java.lang.NullPointerException - if the given string is null.
    
    java.lang.IllegalArgumentException - if anchor is not a valid value.
  - drawSubstring
```
public final void drawSubstring(java.lang.String str,
                                int offset,
                                int len,
                                int x,
                                int y,
                                int anchor)
```
    Draws the string from offset to offset+length using the current font and color.
    The text anchor point is at position (x,y). Position constants may be given to specify the precise location of the text around the anchor point.
    See GraphicsContext for details of anchors.
    
    Parameters:
    
    str - the string to draw.
    
    offset - index of the first character in the string to draw.
    
    len - number of characters to draw from the given offset.
    
    x - the x coordinate of the anchor point.
    
    y - the y coordinate of the anchor point.
    
    anchor - position of the string text around the anchor point.
    
    Throws:
    
    java.lang.StringIndexOutOfBoundsException - if the given offset and length do not specify a valid range within the given string.
    
    java.lang.IllegalArgumentException - if anchor is not a valid value.
    
    java.lang.NullPointerException - if the given string is null.
  - drawChar
```
public final void drawChar(char character,
                           int x,
                           int y,
                           int anchor)
```
    Draws a character using the current font and color.
    The text anchor point is at position (x,y). Position constants may be given to specify the precise location of the character around the anchor point.
    
    Parameters:
    
    character - the character to draw.
    
    x - the x coordinate of the anchor point.
    
    y - the y coordinate of the anchor point.
    
    anchor - position of the character around the anchor point.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value.
  - drawChars
```
public final void drawChars(char[] data,
                            int offset,
                            int length,
                            int x,
                            int y,
                            int anchor)
```
    Draws some characters using the current font and color.
    The text anchor point is at position (x,y). Position constants may be given to specify the precise location of the text around the anchor point.
    
    Parameters:
    
    data - the array of characters to draw.
    
    offset - offset of the first character to draw in the char array.
    
    length - the number of characters to draw from the offset.
    
    x - the x coordinate of the anchor point.
    
    y - the y coordinate of the anchor point.
    
    anchor - position of the text around the anchor point.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the given offset and length do not specify a valid range within the given char array.
    
    java.lang.IllegalArgumentException - if the given anchor is not a valid value.
    
    java.lang.NullPointerException - if the given char array is null.
  - setEllipsis
```
public void setEllipsis(boolean enable)
```
    Enables (disables) truncation when rendering characters. When enabled, a text that would be outside the current clip will have its last visible character replaced by ellipsis (three dots).
    
    Parameters:
    
    enable - true to enable the ellipsis mode, false otherwise.
  - getDisplay
```
public Display getDisplay()
```
    Gets the display associated with the GraphicsContext.
    
    Returns:
    
    the display associated with the GraphicsContext
  - getEllipsis
```
public boolean getEllipsis()
```
    Gets whether the truncation mechanism is enabled or not.
    
    Returns:
    
    true if the truncation mechanism is enabled, false otherwise.

Class GraphicsContext

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

HCENTER

VCENTER

LEFT

RIGHT

TOP

BOTTOM

BASELINE

SOLID

DOTTED

OPAQUE

TRANSPARENT

Method Detail

getAlpha

translate

getTranslateX

getTranslateY

setColor

setBackgroundColor

removeBackgroundColor

getColor

getBackgroundColor

hasBackgroundColor

getDisplayColor

setStrokeStyle

getStrokeStyle

setFont

getFont

clipRect

setClip

getClipX

getClipY

getClipWidth

getClipHeight

drawPixel

readPixel

drawHorizontalLine

drawVerticalLine

drawLine

drawRect

fillRect

drawRoundRect

fillRoundRect

drawPolygon

drawPolygon

fillPolygon

fillPolygon

drawCircleArc

drawEllipseArc

fillCircleArc

fillEllipseArc

drawCircle

fillCircle

drawEllipse

fillEllipse

drawImage

drawImage

drawRegion

drawRegion

drawRegion

drawRegion

getARGB

drawString

drawSubstring

drawChar

drawChars

setEllipsis

getDisplay

getEllipsis