# Class Graphics

java.lang.Object
com.codename1.ui.Graphics

public final class Graphics extends Object

Abstracts the underlying platform graphics context thus allowing us to achieve portability between MIDP devices and CDC devices. This abstaction simplifies and unifies the Graphics implementations of various platforms.

A graphics instance should never be created by the developer and is always accessed using either a paint callback or a mutable image. There is no supported way to create this object directly.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final int`
  `RENDERING_HINT_FAST`
  Rendering hint to indicate that the context should prefer to render primitives in a quick way, at the cost of quality, if there is an expensive operation.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `Object`
  `beginNativeGraphicsAccess()`
  Starts accessing the native graphics in the underlying OS, when accessing the native graphics Codename One shouldn't be used! The native graphics is unclipped and untranslated by default and its the responsibility of the caller to clip/translate appropriately.
  `boolean`
  `blurRegion(int x, int y, int width, int height, float radius)`
  Applies a Gaussian blur to the contents already painted into the rectangular region.
  `void`
  `clearRect(int x, int y, int width, int height)`
  Clears rectangular area of the graphics context.
  `void`
  `clipRect(int x, int y, int width, int height)`
  Clips the given rectangle by intersecting with the current clipping region, this method can thus only shrink the clipping region and never increase it.
  `int`
  `concatenateAlpha(int a)`
  Concatenates the given alpha value to the current alpha setting, and returns the previous alpha setting.
  `void`
  `darkerColor(int factor)`
  Makes the current color slightly darker, this is useful for many visual effects
  `void`
  `drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)`
  Draws a circular or elliptical arc based on the given angles and bounding box
  `void`
  `drawChar(char character, int x, int y)`
  Draw the given char using the current font and color in the x,y coordinates.
  `void`
  `drawChars(char[] data, int offset, int length, int x, int y)`
  Draw the given char array using the current font and color in the x,y coordinates.
  `void`
  `drawImage(Image img, int x, int y)`
  Draws the image so its top left coordinate corresponds to x/y
  `void`
  `drawImage(Image img, int x, int y, int w, int h)`
  `void`
  `drawImageRounded(Image img, int x, int y, int w, int h, float cornerRadius)`
  Draws an image with rounded corners, without building a rounded copy of it, on platforms that support it; elsewhere the image is drawn square.
  `void`
  `drawLine(int x1, int y1, int x2, int y2)`
  Draws a line between the 2 X/Y coordinates
  `void`
  `drawPolygon(int[] xPoints, int[] yPoints, int nPoints)`
  Draws a closed polygon defined by arrays of x and y coordinates.
  `void`
  `drawRect(int x, int y, int width, int height)`
  Draws a rectangle in the given coordinates
  `void`
  `drawRect(int x, int y, int width, int height, int thickness)`
  Draws a rectangle in the given coordinates with the given thickness
  `void`
  `drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)`
  Draws a rounded corner rectangle in the given coordinates with the arcWidth/height matching the last two arguments respectively.
  `void`
  `drawShadow(Image img, int x, int y, int offsetX, int offsetY, int blurRadius, int spreadRadius, int color, float opacity)`

  ###### Deprecated

  `void`
  `drawShape(Shape shape, Stroke stroke)`
  Draws a outline shape inside the specified bounding box.
  `void`
  `drawString(String str, int x, int y)`
  Draw a string using the current font and color in the x,y coordinates.
  `void`
  `drawString(String str, int x, int y, int textDecoration)`
  Draw a string using the current font and color in the x,y coordinates.
  `void`
  `drawStringBaseline(String str, int x, int y)`
  Draws a string using baseline coordinates.
  `void`
  `drawStringBaseline(String str, int x, int y, int textDecoration)`
  Draws a string using baseline coordinates.
  `void`
  `endNativeGraphicsAccess()`
  Invoke this to restore Codename One's graphics settings into the native graphics
  `void`
  `fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)`
  Fills a circular or elliptical arc based on the given angles and bounding box.
  `void`
  `fillGradient(Gradient gradient, int x, int y, int width, int height)`
  Fills the rectangle (x, y, width, height) with the given multi-stop gradient.
  `void`
  `fillLinearGradient(int startColor, int endColor, int x, int y, int width, int height, boolean horizontal)`
  Draws a linear gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient
  `void`
  `fillPolygon(int[] xPoints, int[] yPoints, int nPoints)`
  Fills a closed polygon defined by arrays of x and y coordinates.
  `void`
  `fillRadialGradient(int startColor, int endColor, int x, int y, int width, int height)`
  Draws a radial gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient.
  `void`
  `fillRadialGradient(int startColor, int endColor, int x, int y, int width, int height, int startAngle, int arcAngle)`
  Draws a radial gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient.
  `void`
  `fillRect(int x, int y, int width, int height)`
  Fills the rectangle from the given position according to the width/height minus 1 pixel according to the convention in Java.
  `void`
  `fillRect(int x, int y, int w, int h, byte alpha)`
  Fills a rectangle with an optionally translucent fill color
  `void`
  `fillRectRadialGradient(int startColor, int endColor, int x, int y, int width, int height, float relativeX, float relativeY, float relativeSize)`
  Draws a radial gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient.
  `void`
  `fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)`
  Fills a rounded rectangle in the same way as drawRoundRect
  `void`
  `fillShape(Shape shape)`
  Fills the given shape using the current alpha and color settings.
  `void`
  `fillShapeShadow(Shape shape, int fillColor, int fillAlpha, int shadowColor, float shadowOpacity, int blurRadius, int offsetX, int offsetY)`
  Fills the given shape and casts a blurred drop shadow behind it in a single GPU-accelerated draw where the platform supports it (e.g. Android `Paint.setShadowLayer`, iOS `CGContextSetShadow`), with no retained bitmap.
  `void`
  `fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3)`
  Draws a filled triangle with the given coordinates
  `protected void`
  `finalize()`
  `Image`
  `gaussianBlur(Image source, float radius)`
  Returns a copy of the given image with a Gaussian blur of the given radius applied.
  `int`
  `getAlpha()`
  Returns the alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque and 0 is completely transparent
  `int[]`
  `getClip()`
  Returns the clip as an x,y,w,h array
  `int`
  `getClipHeight()`
  Returns the clip height
  `int`
  `getClipWidth()`
  Returns the clip width
  `int`
  `getClipX()`
  Returns the x clipping position
  `int`
  `getClipY()`
  Returns the y clipping position
  `int`
  `getColor()`
  Returns the current color
  `Font`
  `getFont()`
  Returns the font used with the drawString method calls
  `Paint`
  `getPaint()`
  Gets the current `Paint` that is set to be used for filling shapes.
  `int`
  `getRenderingHints()`
  Gets the current rendering hints for this context.
  `float`
  `getScaleX()`
  Returns the affine X scale
  `float`
  `getScaleY()`
  Returns the affine Y scale
  `Transform`
  `getTransform()`
  Gets the transformation matrix that is currently applied to this graphics context.
  `void`
  `getTransform(Transform t)`
  Loads the provided transform with the current transform applied to this graphics context.
  `int`
  `getTranslateX()`
  Returns the current x translate value
  `int`
  `getTranslateY()`
  Returns the current y translate value
  `boolean`
  `glassRegion(int x, int y, int width, int height, float radius, float cornerRadius, float sat, float scale, float offset, float refract, float specular)`
  Applies the iOS "Liquid Glass" material to the contents already painted into the rectangular region.
  `boolean`
  `isAffineSupported()`
  Indicates whether the underlying implementation can draw using an affine transform hence methods such as rotate, scale and shear would work
  `boolean`
  `isAlphaSupported()`
  Indicates whether invoking set/getAlpha would have an effect on all further rendering from this graphics object.
  `boolean`
  `isAntiAliased()`
  Returns true if antialiasing for standard rendering operations is turned on.
  `boolean`
  `isAntiAliasedText()`
  Indicates whether antialiasing for text is active, notice that text antialiasing is a separate attribute from standard anti-alisaing.
  `boolean`
  `isAntiAliasedTextSupported()`
  Returns true if antialiasing for text is supported, notice that text antialiasing is a separate attribute from standard anti-alisaing.
  `boolean`
  `isAntiAliasingSupported()`
  Returns true if antialiasing for standard rendering operations is supported, notice that text antialiasing is a separate attribute.
  `boolean`
  `isPerspectiveTransformSupported()`
  Checks to see if perspective (3D) `com.codename1.ui.geom.Matrix` transforms are supported by this graphics context.
  `boolean`
  `isRoundedImageSupported()`
  Draws the image so its top left coordinate corresponds to x/y and scales it to width/height
  `boolean`
  `isRoundedImageSupported(Image img)`
  Whether `drawImageRounded(Image, int, int, int, int, float)` will round THIS image, which is the question a caller actually needs answered.
  `boolean`
  `isShapeClipSupported()`
  Checks to see if this graphics context supports clip Shape.
  `boolean`
  `isShapeShadowSupported()`
  Checks whether `#fillShapeShadow` renders a GPU shadow on this platform.
  `boolean`
  `isShapeSupported()`
  Checks to see if this graphics context supports drawing shapes (i.e.
  `boolean`
  `isTransformSupported()`
  Checks to see if `com.codename1.ui.geom.Matrix` transforms are supported by this graphics context.
  `boolean`
  `isTranslateMatrixSupported()`
  Checks whether `#translateMatrix(float, float)` composes through the impl matrix on this port (the matrix-correct mode) versus falling back to the integer `#translate(int, int)` accumulator.
  `boolean`
  `isVisible(int x, int y, int w, int h)`
  Returns true if the given rectangle (in the current Graphics coordinate space, with the active translation applied) intersects the current clip rectangle, i.e.
  `boolean`
  `lensRegion(int x, int y, int width, int height, float cornerRadius, float magnify, float aberration, int tintColor, float tintStrength)`
  Applies the iOS 26 selection "drop" LENS to the contents already painted into the region (the bar + glyphs UNDER it): radial magnification, edge chromatic aberration, and a luminance-keyed dark->accent tint so dark glyphs read in the accent colour only where the lens covers them.
  `void`
  `lighterColor(int factor)`
  Makes the current color slightly lighter, this is useful for many visual effects
  `void`
  `popClip()`
  Pops the top clip from the clip stack and sets it as the current clip.
  `void`
  `pushClip()`
  Pushes the current clip onto the clip stack.
  `void`
  `resetAffine()`
  Resets the affine transform to the default value
  `void`
  `rotate(float angle)`
  Rotates the coordinate system around a radian angle using the affine transform
  `void`
  `rotate(float angle, int pivotX, int pivotY)`
  Rotates the coordinate system around a radian angle using the affine transform
  `void`
  `rotateRadians(float angle)`
  RRotates the coordinate system around a radian angle using the affine transform
  `void`
  `rotateRadians(float angle, int pivotX, int pivotY)`
  Rotates the coordinate system around a radian angle using the affine transform
  `void`
  `scale(float x, float y)`
  Scales the coordinate system using the affine transform
  `void`
  `setAlpha(int a)`
  Sets alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque and 0 is completely transparent
  `int`
  `setAndGetAlpha(int a)`
  Sets alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque and 0 is completely transparent
  `int`
  `setAndGetColor(int rgb)`
  Sets the current rgb color while ignoring any potential alpha component within said color value.
  `void`
  `setAntiAliased(boolean a)`
  Set whether antialiasing for standard rendering operations is turned on.
  `void`
  `setAntiAliasedText(boolean a)`
  Set whether antialiasing for text is active, notice that text antialiasing is a separate attribute from standard anti-alisaing.
  `void`
  `setClip(int[] clip)`
  Sets the clip from an array containing x, y, width, height value
  `void`
  `setClip(int x, int y, int width, int height)`
  Updates the clipping region to match the given region exactly
  `void`
  `setClip(Shape shape)`
  Clips the Graphics context to the Shape.
  `void`
  `setColor(int rgb)`
  Sets the current rgb color while ignoring any potential alpha component within said color value.
  `void`
  `setColor(Paint paint)`
  Sets paint to be used for filling shapes.
  `void`
  `setFont(Font font)`
  Sets the font to use with the drawString method calls
  `void`
  `setRenderingHints(int hints)`
  Sets rendering hints for this context.
  `void`
  `setTransform(Transform transform)`
  Sets the transformation `com.codename1.ui.geom.Matrix` to apply to drawing in this graphics context.
  `void`
  `shear(float x, float y)`
  Shear the graphics coordinate system using the affine transform
  `void`
  `tileImage(Image img, int x, int y, int w, int h)`
  Allows an implementation to optimize image tiling rendering logic
  `void`
  `transform(Transform transform)`
  Concatenates the given transform to the context's transform.
  `void`
  `translate(int x, int y)`
  Translates the X/Y location for drawing on the underlying surface.
  `void`
  `translateMatrix(float x, float y)`
  Translates the coordinate system using the affine transform matrix (as opposed to `#translate(int, int)` which uses a per-Graphics integer accumulator). On every port today `isTranslationSupported() == false`, which means `g.translate(int, int)` is added to draw coordinates before the impl matrix is applied; a subsequent `g.scale()` or `g.rotate()` therefore multiplies the integer translate too. That's surprising when porting code that came from Java2D / AWT where translate composes into the matrix the same way as scale and rotate.

  ### Methods inherited from class Object

  `clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### RENDERING_HINT_FAST

    public static final int RENDERING_HINT_FAST

    Rendering hint to indicate that the context should prefer to render primitives in a quick way, at the cost of quality, if there is an expensive operation.

    ###### See also

    - #setRenderingHints(int)

    - #getRenderingHints()

    See Also:
      - Constant Field Values

- ## Method Details

  - ### finalize

    protected void finalize()

  - ### translate

    public void translate(int x, int y)

    Translates the X/Y location for drawing on the underlying surface. Translation is incremental so the new value will be added to the current translation and in order to reset translation we have to invoke `translate(-getTranslateX(), -getTranslateY())`

    ###### Parameters

    - `x`: the x coordinate

    - `y`: the y coordinate

  - ### getTranslateX

    public int getTranslateX()

    Returns the current x translate value

    ###### Returns

    the current x translate value

  - ### getTranslateY

    public int getTranslateY()

    Returns the current y translate value

    ###### Returns

    the current y translate value

  - ### getColor

    public int getColor()

    Returns the current color

    ###### Returns

    the RGB graphics color

  - ### setColor

    public void setColor(int rgb)

    Sets the current rgb color while ignoring any potential alpha component within said color value.

    ###### Parameters

    - `rgb`: the RGB value for the color.

  - ### setColor

    public void setColor(Paint paint)

    Sets paint to be used for filling shapes. This is only used for the `#fillShape(com.codename1.ui.geom.Shape)` method.

    ###### Parameters

    - `paint`

    ###### See also

    - LinearGradientPaint

  - ### getPaint

    public Paint getPaint()

    Gets the current `Paint` that is set to be used for filling shapes.

    ###### Returns

    The paint that is to be used for filling shapes.

    ###### See also

    - LinearGradientPaint

  - ### setAndGetColor

    public int setAndGetColor(int rgb)

    Sets the current rgb color while ignoring any potential alpha component within said color value.

    ###### Parameters

    - `rgb`: the RGB value for the color.

    ###### Returns

    The previous color value.

  - ### getFont

    public Font getFont()

    Returns the font used with the drawString method calls

    ###### Returns

    the font used with the drawString method calls

  - ### setFont

    public void setFont(Font font)

    Sets the font to use with the drawString method calls

    ###### Parameters

    - `font`: the font used with the drawString method calls

  - ### getClipX

    public int getClipX()

    Returns the x clipping position

    ###### Returns

    the x clipping position

  - ### getClip

    public int[] getClip()

    Returns the clip as an x,y,w,h array

    ###### Returns

    clip array copy

  - ### setClip

    public void setClip(int[] clip)

    Sets the clip from an array containing x, y, width, height value

    ###### Parameters

    - `clip`: 4 element array

  - ### setClip

    public void setClip(Shape shape)

    Clips the Graphics context to the Shape.

    This is not supported on all platforms and contexts currently. Use `#isShapeClipSupported` to check if the current context supports clipping shapes.

        Image duke = null;
        try {
            // duke.png is just the default Codename One icon copied into place
            duke = Image.createImage("/duke.png");
        } catch(IOException err) {
            Log.e(err);
        }
        final Image finalDuke = duke;

        Form hi = new Form("Shape Clip");

        // We create a 50 x 100 shape, this is arbitrary since we can scale it easily
        GeneralPath path = new GeneralPath();
        path.moveTo(20,0);
        path.lineTo(30, 0);
        path.lineTo(30, 100);
        path.lineTo(20, 100);
        path.lineTo(20, 15);
        path.lineTo(5, 40);
        path.lineTo(5, 25);
        path.lineTo(20,0);

        Stroke stroke = new Stroke(0.5f, Stroke.CAP_ROUND, Stroke.JOIN_ROUND, 4);
        hi.getContentPane().getUnselectedStyle().setBgPainter(new Painter() {
            public void paint(Graphics g, Rectangle rect) {
            g.setColor(0xff);
            float widthRatio = ((float)rect.getWidth()) / 50f;
            float heightRatio = ((float)rect.getHeight()) / 100f;
            g.scale(widthRatio, heightRatio);
            g.translate((int)(((float)rect.getX()) / widthRatio), (int)(((float)rect.getY()) / heightRatio));
            g.setClip(path);
            g.setAntiAliased(true);
            g.drawImage(finalDuke, 0, 0, 50, 100);
            g.setClip(path.getBounds());
            g.drawShape(path, stroke);
            g.translate(-(int)(((float)rect.getX()) / widthRatio), -(int)(((float)rect.getY()) / heightRatio));
            g.resetAffine();
            }
        });

        hi.show();

    ###### Parameters

    - `shape`: The shape to clip.

    ###### See also

    - #isShapeClipSupported

  - ### getClipY

    public int getClipY()

    Returns the y clipping position

    ###### Returns

    the y clipping position

  - ### getClipWidth

    public int getClipWidth()

    Returns the clip width

    ###### Returns

    the clip width

  - ### getClipHeight

    public int getClipHeight()

    Returns the clip height

    ###### Returns

    the clip height

  - ### isVisible

    public boolean isVisible(int x, int y, int w, int h)

    Returns true if the given rectangle (in the current Graphics coordinate space, with the active translation applied) intersects the current clip rectangle, i.e. anything drawn into it would be at least partially visible.

    Use this to skip work for off-screen draws - typical case is a zoomed canvas where most images fall outside the visible window and should not be decoded or scaled.

        if (g.isVisible(x, y, w, h)) {
            g.drawImage(image, x, y, w, h);
        }

    When a non-identity affine transform is in effect (see `setTransform(Transform)`), the four corners of the rectangle are mapped through the current transform and the axis-aligned bounding box of the result is tested against the clip. This means a rotated/scaled rectangle is judged by where it actually lands on screen rather than by its untransformed coordinates. The integer translate (`translate(int, int)`) is intentionally not added here: `getClipX()`/`getClipY()` are already reported in the same untranslated coordinate space you pass to draw calls, so the translation cancels out.

    Note: shape-clipped graphics (`setClip(Shape)`) fall back to the bounding rectangle of the clip, and perspective (3D) transforms are approximated by their 2D corner projection; this matches the precision actually used by the platform draw calls.

    ###### Parameters

    - `x`: left edge of the rectangle

    - `y`: top edge of the rectangle

    - `w`: width of the rectangle

    - `h`: height of the rectangle

    ###### Returns

    true if the rectangle intersects the current clip

  - ### clipRect

    public void clipRect(int x, int y, int width, int height)

    Clips the given rectangle by intersecting with the current clipping region, this method can thus only shrink the clipping region and never increase it.

    ###### Parameters

    - `x`: the x coordinate of the rectangle to intersect the clip with

    - `y`: the y coordinate of the rectangle to intersect the clip with

    - `width`: the width of the rectangle to intersect the clip with

    - `height`: the height of the rectangle to intersect the clip with

  - ### setClip

    public void setClip(int x, int y, int width, int height)

    Updates the clipping region to match the given region exactly

    ###### 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.

  - ### pushClip

    public void pushClip()
    Pushes the current clip onto the clip stack. It can later be restored using `#popClip`.

  - ### popClip

    public void popClip()
    Pops the top clip from the clip stack and sets it as the current clip.

  - ### drawLine

    public void drawLine(int x1, int y1, int x2, int y2)

    Draws a line between the 2 X/Y coordinates

    ###### Parameters

    - `x1`: first x position

    - `y1`: first y position

    - `x2`: second x position

    - `y2`: second y position

  - ### fillRect

    public void fillRect(int x, int y, int width, int height)

    Fills the rectangle from the given position according to the width/height minus 1 pixel according to the convention in Java.

    ###### 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.

  - ### drawShadow

    public void drawShadow(Image img, int x, int y, int offsetX, int offsetY, int blurRadius, int spreadRadius, int color, float opacity)

    ###### Deprecated

    this method should have been internals

  - ### clearRect

    public void clearRect(int x, int y, int width, int height)

    Clears rectangular area of the graphics context. This will remove any color information that has already been drawn to the graphics context making it transparent.

    The difference between this method and say `int, int, int)` with alpha=0 is that fillRect() will just blend with the colors underneath (and thus `int, int, int)` with an alpha of 0 actually does nothing.

    NOTE: In contrast to other drawing methods, coordinates input here are absolute and will not be adjusted by the xTranslate and yTranslate values

    This method is designed to be used by `#drawPeerComponent(com.codename1.ui.PeerComponent)` only.

    ###### Parameters

    - `x`: The x-coordinate of the box to clear. In screen coordinates.

    - `y`: The y-coordinate of the box to clear. In screen coordinates.

    - `width`: The width of the box to clear.

    - `height`: The height of the box to clear.

  - ### drawRect

    public void drawRect(int x, int y, int width, int height)

    Draws a rectangle in the given coordinates

    ###### Parameters

    - `x`: the x coordinate of the rectangle to be drawn.

    - `y`: the y coordinate of the rectangle to be drawn.

    - `width`: the width of the rectangle to be drawn.

    - `height`: the height of the rectangle to be drawn.

  - ### drawRect

    public void drawRect(int x, int y, int width, int height, int thickness)

    Draws a rectangle in the given coordinates with the given thickness

    ###### Parameters

    - `x`: the x coordinate of the rectangle to be drawn.

    - `y`: the y coordinate of the rectangle to be drawn.

    - `width`: the width of the rectangle to be drawn.

    - `height`: the height of the rectangle to be drawn.

    - `thickness`: the thickness in pixels

  - ### drawRoundRect

    public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)

    Draws a rounded corner rectangle in the given coordinates with the arcWidth/height matching the last two arguments respectively.

    ###### Parameters

    - `x`: the x coordinate of the rectangle to be drawn.

    - `y`: the y coordinate of the rectangle to be drawn.

    - `width`: the width of the rectangle to be drawn.

    - `height`: the height of the rectangle to be drawn.

    - `arcWidth`: the horizontal diameter of the arc at the four corners.

    - `arcHeight`: the vertical diameter of the arc at the four corners.

  - ### lighterColor

    public void lighterColor(int factor)

    Makes the current color slightly lighter, this is useful for many visual effects

    ###### Parameters

    - `factor`: the degree of lightening a color per channel a number from 1 to 255

  - ### darkerColor

    public void darkerColor(int factor)

    Makes the current color slightly darker, this is useful for many visual effects

    ###### Parameters

    - `factor`: the degree of lightening a color per channel a number from 1 to 255

  - ### fillRoundRect

    public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)

    Fills a rounded rectangle in the same way as drawRoundRect

    ###### 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.

    - `arcWidth`: the horizontal diameter of the arc at the four corners.

    - `arcHeight`: the vertical diameter of the arc at the four corners.

    ###### See also

    - #drawRoundRect

  - ### fillArc

    public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)

    Fills a circular or elliptical arc based on the given angles and bounding box. The resulting arc begins at startAngle and extends for arcAngle degrees. Usage:

        Form hi = new Form("fillArc / drawArc", new BorderLayout());
        Container cmp = new Container();
        cmp.setPreferredSize(new Dimension(300, 300));
        Painter p = new Painter() {
            public void paint(Graphics g, Rectangle rect) {
                boolean antiAliased = g.isAntiAliased();
                g.setAntiAliased(true);
                int r = Math.min(rect.getWidth(), rect.getHeight()) / 2;
                int x = rect.getX() + rect.getWidth() / 2 - r;
                int y = rect.getY() + rect.getHeight() / 2 - r;
                g.setColor(0x4488ff);
                g.fillArc(x, y, 2 * r, 2 * r, 0, 360);
                g.setColor(0xffffff);
                g.drawArc(x, y, 2 * r - 1, 2 * r - 1, 0, 360);
                g.setAntiAliased(antiAliased);
            }
        };
        cmp.getAllStyles().setBgPainter(p);
        hi.add(BorderLayout.CENTER, cmp);
        hi.show();

    ###### Parameters

    - `x`: the x coordinate of the upper-left corner of the arc to be filled.

    - `y`: the y coordinate of the upper-left corner of the arc to be filled.

    - `width`: the width of the arc to be filled, must be 1 or more.

    - `height`: the height of the arc to be filled, must be 1 or more.

    - `startAngle`: the beginning angle.

    - `arcAngle`: the angular extent of the arc, relative to the start angle.

  - ### drawArc

    public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)

    Draws a circular or elliptical arc based on the given angles and bounding box

    ###### Parameters

    - `x`: the x coordinate of the upper-left corner of the arc to be drawn.

    - `y`: the y coordinate of the upper-left corner of the arc to be drawn.

    - `width`: the width of the arc to be drawn.

    - `height`: the height of the arc to be drawn.

    - `startAngle`: the beginning angle.

    - `arcAngle`: the angular extent of the arc, relative to the start angle.

  - ### drawString

    public void drawString(String str, int x, int y, int textDecoration)

    Draw a string using the current font and color in the x,y coordinates. The font is drawn from the top position and not the baseline.

    ###### Parameters

    - `str`: the string to be drawn.

    - `x`: the x coordinate.

    - `y`: the y coordinate.

    - `textDecoration`: Text decoration bitmask (See Style's TEXT_DECORATION_* constants)

  - ### drawStringBaseline

    public void drawStringBaseline(String str, int x, int y)

    Draws a string using baseline coordinates.

    ###### Parameters

    - `str`: The string to be drawn.

    - `x`: The x-coordinate of the start of left edge of the text block.

    - `y`: The y-coordinate of the baseline of the text.

    ###### See also

    - #drawString(java.lang.String, int, int)

  - ### drawStringBaseline

    public void drawStringBaseline(String str, int x, int y, int textDecoration)

    Draws a string using baseline coordinates.

    ###### Parameters

    - `str`: The string to be drawn.

    - `x`: The x-coordinate of the start of left edge of the text block.

    - `y`: The y-coordinate of the baseline of the text.

    - `textDecoration`: Text decoration bitmask (See Style's TEXT_DECORATION_* constants)

    ###### See also

    - #drawString(java.lang.String, int, int, int)

  - ### drawString

    public void drawString(String str, int x, int y)

    Draw a string using the current font and color in the x,y coordinates. The font is drawn from the top position and not the baseline.

    ###### Parameters

    - `str`: the string to be drawn.

    - `x`: the x coordinate.

    - `y`: the y coordinate.

  - ### drawChar

    public void drawChar(char character, int x, int y)

    Draw the given char using the current font and color in the x,y coordinates. The font is drawn from the top position and not the baseline.

    ###### Parameters

    - `character`: - the character to be drawn

    - `x`: the x coordinate of the baseline of the text

    - `y`: the y coordinate of the baseline of the text

    ###### Deprecated

    use drawString instead, this method is inefficient

  - ### drawChars

    public void drawChars(char[] data, int offset, int length, int x, int y)

    Draw the given char array using the current font and color in the x,y coordinates. The font is drawn from the top position and not the baseline.

    ###### Parameters

    - `data`: the array of characters to be drawn

    - `offset`: the start offset in the data

    - `length`: the number of characters to be drawn

    - `x`: the x coordinate of the baseline of the text

    - `y`: the y coordinate of the baseline of the text

    ###### Deprecated

    use drawString instead, this method is inefficient

  - ### drawImage

    public void drawImage(Image img, int x, int y)

    Draws the image so its top left coordinate corresponds to x/y

    ###### Parameters

    - `img`: @param img the specified image to be drawn. This method does nothing if img is null.

    - `x`: the x coordinate.

    - `y`: the y coordinate.

  - ### isRoundedImageSupported

    public boolean isRoundedImageSupported()

    Draws the image so its top left coordinate corresponds to x/y and scales it to width/height

    ###### Parameters

    - `img`: @param img the specified image to be drawn. This method does nothing if img is null.

    - `x`: the x coordinate.

    - `y`: the y coordinate.

    - `w`: the width to occupy

    - `h`: the height to occupy Whether this platform can round a picture's corners as it draws it.

    When it cannot, the only way to get rounded corners is to build a rounded COPY of the bitmap -- read the pixels back, clear the alpha outside the corner arcs and upload the result -- which is a full pixel round trip and a second texture per picture. Code that wants rounded artwork should ask here and keep that copy as its fallback.

    ###### Returns

    true if `drawImageRounded(Image, int, int, int, int, float)` rounds

  - ### isRoundedImageSupported

    public boolean isRoundedImageSupported(Image img)

    Whether `drawImageRounded(Image, int, int, int, int, float)` will round THIS image, which is the question a caller actually needs answered.

    The platform may round and still not be able to round a given picture. Drawing an Image is a virtual call, and ComponentImage, DynamicImage, FontImage, RGBImage and SVGScaledView paint procedurally rather than handing over a bitmap; a rotated image keeps its angle beside a shared peer. None of those can be handed to a rounded draw without losing the drawing or the rotation, so they come out square.

    A caller that consults the no-argument method alone therefore skips its own rounded-copy fallback on a platform that advertises support and gets square artwork for exactly those images. Ask this one per picture.

    ###### Parameters

    - `img`: the image about to be drawn

    ###### Returns

    true if this image will be rounded; false to use the copy fallback

  - ### drawImageRounded

    public void drawImageRounded(Image img, int x, int y, int w, int h, float cornerRadius)

    Draws an image with rounded corners, without building a rounded copy of it, on platforms that support it; elsewhere the image is drawn square.

    The corners are anti-aliased where the platform draws them analytically, which a shaped clip of the same outline is not.

    ###### Parameters

    - `img`: the image to draw
    - `x`: destination x
    - `y`: destination y
    - `w`: destination width
    - `h`: destination height
    - `cornerRadius`: radius in pixels, clamped to half the smaller side

  - ### drawImage

    public void drawImage(Image img, int x, int y, int w, int h)

  - ### drawShape

    public void drawShape(Shape shape, Stroke stroke)

    Draws a outline shape inside the specified bounding box. The bounding box will resize the shape to fit in its dimensions.

    This is not supported on all platforms and contexts currently. Use `#isShapeSupported` to check if the current context supports drawing shapes.

        Form hi = new Form("Shape");

        // We create a 50 x 100 shape, this is arbitrary since we can scale it easily
        GeneralPath path = new GeneralPath();
        path.moveTo(20,0);
        path.lineTo(30, 0);
        path.lineTo(30, 100);
        path.lineTo(20, 100);
        path.lineTo(20, 15);
        path.lineTo(5, 40);
        path.lineTo(5, 25);
        path.lineTo(20,0);

        hi.getContentPane().getUnselectedStyle().setBgPainter(new Painter() {
            public void paint(Graphics g, Rectangle rect) {
            g.setColor(0xff);
            float widthRatio = ((float)rect.getWidth()) / 50f;
            float heightRatio = ((float)rect.getHeight()) / 100f;
            g.scale(widthRatio, heightRatio);
            g.translate((int)(((float)rect.getX()) / widthRatio), (int)(((float)rect.getY()) / heightRatio));
            g.fillShape(path);
            g.resetAffine();
            }
        });

        hi.show();

    ###### Parameters

    - `shape`: The shape to be drawn.

    - `stroke`: the stroke to use

    ###### See also

    - #setStroke

    - #isShapeSupported

  - ### fillShape

    public void fillShape(Shape shape)

    Fills the given shape using the current alpha and color settings.

    This is not supported on all platforms and contexts currently. Use `#isShapeSupported` to check if the current context supports drawing shapes.

        Form hi = new Form("Shape");

        // We create a 50 x 100 shape, this is arbitrary since we can scale it easily
        GeneralPath path = new GeneralPath();
        path.moveTo(20,0);
        path.lineTo(30, 0);
        path.lineTo(30, 100);
        path.lineTo(20, 100);
        path.lineTo(20, 15);
        path.lineTo(5, 40);
        path.lineTo(5, 25);
        path.lineTo(20,0);

        hi.getContentPane().getUnselectedStyle().setBgPainter(new Painter() {
            public void paint(Graphics g, Rectangle rect) {
            g.setColor(0xff);
            float widthRatio = ((float)rect.getWidth()) / 50f;
            float heightRatio = ((float)rect.getHeight()) / 100f;
            g.scale(widthRatio, heightRatio);
            g.translate((int)(((float)rect.getX()) / widthRatio), (int)(((float)rect.getY()) / heightRatio));
            g.fillShape(path);
            g.resetAffine();
            }
        });

        hi.show();

    Note: You can specify a custom `Paint` to use for filling the shape using the `#setColor(com.codename1.ui.Paint)` method. This is useful for filling the shape with a `LinearGradientPaint`, for example.

    ###### Parameters

    - `shape`: The shape to be filled.

    ###### See also

    - #isShapeSupported

  - ### fillShapeShadow

    public void fillShapeShadow(Shape shape, int fillColor, int fillAlpha, int shadowColor, float shadowOpacity, int blurRadius, int offsetX, int offsetY)

    Fills the given shape and casts a blurred drop shadow behind it in a single GPU-accelerated draw where the platform supports it (e.g. Android `Paint.setShadowLayer`, iOS `CGContextSetShadow`), with no retained bitmap. This lets borders/decorations render soft shadows every frame without caching a per-component image. Guard with `#isShapeShadowSupported()` and fall back to your own path otherwise.

    ###### Parameters

    - `shape`: the shape to fill (and whose fill casts the shadow)

    - `fillColor`: the fill color as 0xRRGGBB

    - `fillAlpha`: the fill alpha 0..255

    - `shadowColor`: the shadow color as 0xRRGGBB

    - `shadowOpacity`: the shadow opacity in the range 0..1

    - `blurRadius`: the gaussian blur radius in pixels

    - `offsetX`: the shadow x offset in pixels

    - `offsetY`: the shadow y offset in pixels

  - ### isShapeShadowSupported

    public boolean isShapeShadowSupported()

    Checks whether `#fillShapeShadow` renders a GPU shadow on this platform. When false the caller should draw its shadow another way (e.g. the cached-image fallback in `RoundRectBorder`).

    ###### Returns

    true if a GPU shape shadow is supported by the current graphics context

  - ### isTransformSupported

    public boolean isTransformSupported()

    Checks to see if `com.codename1.ui.geom.Matrix` transforms are supported by this graphics context.

    ###### Returns

    Returns:

      true if this graphics context supports `com.codename1.ui.geom.Matrix` transforms.

      Note that this method only confirms that 2D transforms are supported. If you need to perform 3D transformations, you should use the `#isPerspectiveTransformSupported` method.

      ###### See also

      - #setTransform

      - #getTransform

      - #isPerspectiveTransformSupported

  - public boolean isPerspectiveTransformSupported()

    Checks to see if perspective (3D) `com.codename1.ui.geom.Matrix` transforms are supported by this graphics context. If 3D transforms are supported, you can use a 4x4 transformation `com.codename1.ui.geom.Matrix` via `#setTransform` to perform 3D transforms.

    Note: It is possible for 3D transforms to not be supported but Affine (2D) transforms to be supported. In this case you would be limited to a 3x3 transformation matrix in `#setTransform`. You can check for 2D transformation support using the `#isTransformSupported` method.

    ###### Returns

    true if Perspective (3D) transforms are supported. false otherwise.

    ###### See also

    - #isTransformSupported

    - #setTransform

    - #getTransform

  - ### isShapeSupported

    public boolean isShapeSupported()

    Checks to see if this graphics context supports drawing shapes (i.e. `#drawShape` and `#fillShape` methods. If this returns false, and you call `#drawShape` or `#fillShape`, then nothing will be drawn.

    ###### Returns

    true If `#drawShape` and `#fillShape` are supported.

    ###### See also

    - #drawShape

    - #fillShape

  - ### isShapeClipSupported

    public boolean isShapeClipSupported()

    Checks to see if this graphics context supports clip Shape. If this returns false, calling setClip(Shape) will have no effect on the Graphics clipping area

    ###### Returns

    true If setClip(Shape) is supported.

  - ### transform

    public void transform(Transform transform)

    Concatenates the given transform to the context's transform.

    ###### Parameters

    - `transform`: The transform to concatenate.

  - ### getTransform

    public Transform getTransform()

    Gets the transformation matrix that is currently applied to this graphics context.

    Unlike `java.awt.Graphics2D.getTransform()`, the matrix returned here does not include the integer translation set via `#translate(int, int)`. Codename One keeps that translation as a separate accumulator (`#getTranslateX()` / `#getTranslateY()`) that is applied independently of the affine matrix, so a freshly-translated context still reports the identity transform. This split is deliberate: `#setTransform` / `getTransform` / `#transform(com.codename1.ui.Transform)` round-trip correctly only because the translate is excluded here -- folding it in would cause it to be counted twice (once in the matrix, once in the drawing pipeline).

    Consequently, to map a point from the current drawing coordinate space to the context's device coordinates you must add the translation yourself:

        float[] pt = { x + g.getTranslateX(), y + g.getTranslateY() };
        g.getTransform().transformPoint(pt, pt);
        // pt now holds the transformed device coordinates

    If you only need to know whether a rectangle would be drawn on screen, prefer `#isVisible(int, int, int, int)`, which performs this mapping (translate + transform) internally and tests it against the clip.

    ###### Returns

    The current transformation matrix, excluding the integer translate.

    ###### Deprecated

    Use `#getTransform(com.codename1.ui.Transform)` instead.

    ###### See also

    - #setTransform

    - #getTranslateX

    - #isVisible(int, int, int, int)

  - ### setTransform

    public void setTransform(Transform transform)

    Sets the transformation `com.codename1.ui.geom.Matrix` to apply to drawing in this graphics context. In order to use this for 2D/Affine transformations you should first check to make sure that transforms are supported by calling the `#isTransformSupported` method. For 3D/Perspective transformations, you should first check to make sure that 3D/Perspective transformations are supported by calling the `#isPerspectiveTransformSupported`.

    Transformations are applied with (0,0) as the origin. So rotations and scales are anchored at this point on the screen. You can use a different anchor point by either embedding it in the transformation matrix (i.e. pre-transform the `com.codename1.ui.geom.Matrix` to anchor at a different point) or use the `int, int)` variation that allows you to explicitly set the anchor point.

    ###### Parameters

    - `transform`: @param transform The transformation `com.codename1.ui.geom.Matrix` to use for drawing. 2D/Affine transformations can be achieved using a 3x3 transformation `com.codename1.ui.geom.Matrix`. 3D/Perspective transformations can be achieved using a 4x3 transformation `com.codename1.ui.geom.Matrix`.

    ###### See also

    - #isTransformSupported

    - #isPerspectiveTransformSupported

    - #setTransform(com.codename1.ui.geom.Matrix, int, int)

  - ### getTransform

    public void getTransform(Transform t)

    Loads the provided transform with the current transform applied to this graphics context.

    As with `#getTransform()`, the loaded matrix does not include the integer translation set via `#translate(int, int)`; add `#getTranslateX()` / `#getTranslateY()` to a point before transforming it if you need device coordinates.

    ###### Parameters

    - `t`: An "out" parameter to be filled with the current transform.

  - ### fillTriangle

    public void fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3)

    Draws a filled triangle with the given coordinates

    ###### Parameters

    - `x1`: the x coordinate of the first vertex of the triangle

    - `y1`: the y coordinate of the first vertex of the triangle

    - `x2`: the x coordinate of the second vertex of the triangle

    - `y2`: the y coordinate of the second vertex of the triangle

    - `x3`: the x coordinate of the third vertex of the triangle

    - `y3`: the y coordinate of the third vertex of the triangle

  - ### fillRadialGradient

    public void fillRadialGradient(int startColor, int endColor, int x, int y, int width, int height)

    Draws a radial gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient. Notice that a radial gradient will result in a circular shape, to create a square use fillRect or draw a larger shape and clip to the appropriate size.

    ###### Parameters

    - `startColor`: the starting RGB color

    - `endColor`: the ending RGB color

    - `x`: the x coordinate

    - `y`: the y coordinate

    - `width`: the width of the region to be filled

    - `height`: the height of the region to be filled

  - ### fillRadialGradient

    public void fillRadialGradient(int startColor, int endColor, int x, int y, int width, int height, int startAngle, int arcAngle)

    Draws a radial gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient. Notice that a radial gradient will result in a circular shape, to create a square use fillRect or draw a larger shape and clip to the appropriate size.

    ###### Parameters

    - `startColor`: the starting RGB color

    - `endColor`: the ending RGB color

    - `x`: the x coordinate

    - `y`: the y coordinate

    - `width`: the width of the region to be filled

    - `height`: the height of the region to be filled

    - `startAngle`: the beginning angle. Zero is at 3 o'clock. Positive angles are counter-clockwise.

    - `arcAngle`: the angular extent of the arc, relative to the start angle. Positive angles are counter-clockwise.

  - ### fillRectRadialGradient

    public void fillRectRadialGradient(int startColor, int endColor, int x, int y, int width, int height, float relativeX, float relativeY, float relativeSize)

    Draws a radial gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient. Notice that this method differs from fillRadialGradient since it draws a square gradient at all times and can thus be cached Notice that a radial gradient will result in a circular shape, to create a square use fillRect or draw a larger shape and clip to the appropriate size.

    ###### Parameters

    - `startColor`: the starting RGB color

    - `endColor`: the ending RGB color

    - `x`: the x coordinate

    - `y`: the y coordinate

    - `width`: the width of the region to be filled

    - `height`: the height of the region to be filled

    - `relativeX`: indicates the relative position of the gradient within the drawing region

    - `relativeY`: indicates the relative position of the gradient within the drawing region

    - `relativeSize`: indicates the relative size of the gradient within the drawing region

  - ### fillLinearGradient

    public void fillLinearGradient(int startColor, int endColor, int x, int y, int width, int height, boolean horizontal)

    Draws a linear gradient in the given coordinates with the given colors, doesn't take alpha into consideration when drawing the gradient

    ###### Parameters

    - `startColor`: the starting RGB color

    - `endColor`: the ending RGB color

    - `x`: the x coordinate

    - `y`: the y coordinate

    - `width`: the width of the region to be filled

    - `height`: the height of the region to be filled

    - `horizontal`: indicating wheter it is a horizontal fill or vertical

  - ### fillGradient

    public void fillGradient(Gradient gradient, int x, int y, int width, int height)
    Fills the rectangle (x, y, width, height) with the given multi-stop gradient. The Gradient may be a `LinearGradient`, `RadialGradient`, or `ConicGradient` - the port picks the right native shader path (Java2D `LinearGradientPaint`/`RadialGradientPaint` on JavaSE; Android `LinearGradient`/`RadialGradient`/`SweepGradient` shaders; software rasterizer fallback elsewhere). Pass null or width/height <= 0 for a no-op.

  - ### gaussianBlur

    public Image gaussianBlur(Image source, float radius)
    Returns a copy of the given image with a Gaussian blur of the given radius applied. Equivalent to the CSS filter:blur() effect on an image.

  - ### blurRegion

    public boolean blurRegion(int x, int y, int width, int height, float radius)
    Applies a Gaussian blur to the contents already painted into the rectangular region. Used to realize CSS backdrop-filter:blur(). Returns true if the port supports an in-place blur; otherwise the caller should fall back to snapshot + gaussianBlur().

  - ### glassRegion

    public boolean glassRegion(int x, int y, int width, int height, float radius, float cornerRadius, float sat, float scale, float offset, float refract, float specular)
    Applies the iOS "Liquid Glass" material to the contents already painted into the rectangular region. This is a blur followed by an affine colour transform (saturation boost + scale + offset). The material is masked to a rounded rectangle of the given corner radius (in pixels; a negative value means a full capsule/pill) so it matches the host component's shape rather than spilling into a square. Used to realize the frosted glass backdrop-filter material.

  - ### lensRegion

    public boolean lensRegion(int x, int y, int width, int height, float cornerRadius, float magnify, float aberration, int tintColor, float tintStrength)
    Applies the iOS 26 selection "drop" LENS to the contents already painted into the region (the bar + glyphs UNDER it): radial magnification, edge chromatic aberration, and a luminance-keyed dark->accent tint so dark glyphs read in the accent colour only where the lens covers them. Unlike glassRegion this is drawn OVER the content. cornerRadius<0 = capsule. tintColor is 0xRRGGBB.

  - ### fillRect

    public void fillRect(int x, int y, int w, int h, byte alpha)

    Fills a rectangle with an optionally translucent fill color

    ###### Parameters

    - `x`: the x coordinate of the rectangle to be filled

    - `y`: the y coordinate of the rectangle to be filled

    - `w`: the width of the rectangle to be filled

    - `h`: the height of the rectangle to be filled

    - `alpha`: the alpha values specify semitransparency

  - ### fillPolygon

    public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints)

    Fills a closed polygon defined by arrays of x and y coordinates. Each pair of (x, y) coordinates defines a point.

    ###### Parameters

    - `xPoints`: - a an array of x coordinates.

    - `yPoints`: - a an array of y coordinates.

    - `nPoints`: - a the total number of points.

  - ### drawPolygon

    public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)

    Draws a closed polygon defined by arrays of x and y coordinates. Each pair of (x, y) coordinates defines a point.

    ###### Parameters

    - `xPoints`: - an array of x coordinates.

    - `yPoints`: - an array of y coordinates.

    - `nPoints`: - the total number of points.

  - ### isAlphaSupported

    public boolean isAlphaSupported()

    Indicates whether invoking set/getAlpha would have an effect on all further rendering from this graphics object.

    ###### Returns

    false if setAlpha has no effect true if it applies to everything some effect

  - ### setAndGetAlpha

    public int setAndGetAlpha(int a)

    Sets alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque and 0 is completely transparent

    ###### Parameters

    - `a`: the alpha value

    ###### Returns

    The previous alpha value.

  - ### concatenateAlpha

    public int concatenateAlpha(int a)

    Concatenates the given alpha value to the current alpha setting, and returns the previous alpha setting.

    ###### Parameters

    - `a`: Alpha value to concatenate (0-255).

    ###### Returns

    The previous alpha setting (0-255).

  - ### getAlpha

    public int getAlpha()

    Returns the alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque and 0 is completely transparent

    ###### Returns

    the alpha value

  - ### setAlpha

    public void setAlpha(int a)

    Sets alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque and 0 is completely transparent

    ###### Parameters

    - `a`: the alpha value

  - ### isAntiAliasingSupported

    public boolean isAntiAliasingSupported()

    Returns true if antialiasing for standard rendering operations is supported, notice that text antialiasing is a separate attribute.

    ###### Returns

    true if antialiasing is supported

  - ### isAntiAliasedTextSupported

    public boolean isAntiAliasedTextSupported()

    Returns true if antialiasing for text is supported, notice that text antialiasing is a separate attribute from standard anti-alisaing.

    ###### Returns

    true if text antialiasing is supported

  - ### isAntiAliased

    public boolean isAntiAliased()

    Returns true if antialiasing for standard rendering operations is turned on.

    ###### Returns

    true if antialiasing is active

  - ### setAntiAliased

    public void setAntiAliased(boolean a)

    Set whether antialiasing for standard rendering operations is turned on.

    ###### Parameters

    - `a`: true if antialiasing is active

  - ### isAntiAliasedText

    public boolean isAntiAliasedText()

    Indicates whether antialiasing for text is active, notice that text antialiasing is a separate attribute from standard anti-alisaing.

    ###### Returns

    true if text antialiasing is supported

  - ### setAntiAliasedText

    public void setAntiAliasedText(boolean a)

    Set whether antialiasing for text is active, notice that text antialiasing is a separate attribute from standard anti-alisaing.

    ###### Parameters

    - `a`: true if text antialiasing is supported

  - ### isAffineSupported

    public boolean isAffineSupported()

    Indicates whether the underlying implementation can draw using an affine transform hence methods such as rotate, scale and shear would work

    ###### Returns

    true if an affine transformation matrix is present

  - ### resetAffine

    public void resetAffine()
    Resets the affine transform to the default value

  - ### scale

    public void scale(float x, float y)

    Scales the coordinate system using the affine transform

    ###### Parameters

    - `x`: scale factor for x

    - `y`: scale factor for y

  - ### translateMatrix

    public void translateMatrix(float x, float y)

    Translates the coordinate system using the affine transform matrix (as opposed to `#translate(int, int)` which uses a per-Graphics integer accumulator). On every port today `isTranslationSupported() == false`, which means `g.translate(int, int)` is added to draw coordinates before the impl matrix is applied; a subsequent `g.scale()` or `g.rotate()` therefore multiplies the integer translate too. That's surprising when porting code that came from Java2D / AWT where translate composes into the matrix the same way as scale and rotate.

    `translateMatrix` composes the translation directly onto the impl matrix, exactly like `#scale(float, float)` and `#rotate(float)` do. The result is uniform "post-multiply translate onto the current transform" semantics across iOS / JavaSE / Android / JavaScript -- the same code produces the same on-screen position regardless of which port you target or whether you're drawing into a Form's Graphics or a mutable Image's Graphics.

    On ports where `#isTranslateMatrixSupported()` returns false (e.g. the legacy JavaScript port) the call falls back to the integer `#translate(int, int)` so apps don't silently render at the wrong position -- the visual result on those ports matches whatever `translate(int, int)` does there.

    ###### Parameters

    - `x`: x-axis translation

    - `y`: y-axis translation

    ###### See also

    - `#isTranslateMatrixSupported()`
    - `#translate(int, int)`
    - `#scale(float, float)`
    - `#rotateRadians(float, int, int)`

  - ### isTranslateMatrixSupported

    public boolean isTranslateMatrixSupported()

    Checks whether `#translateMatrix(float, float)` composes through the impl matrix on this port (the matrix-correct mode) versus falling back to the integer `#translate(int, int)` accumulator. Use this to gate code that needs matrix-correct translation semantics.

    ###### Returns

    true if `translateMatrix` reaches the impl matrix; false on ports where it falls back to the integer accumulator.

    ###### See also

    - `#translateMatrix(float, float)`

  - ### rotate

    public void rotate(float angle)

    Rotates the coordinate system around a radian angle using the affine transform

    ###### Parameters

    - `angle`: the rotation angle in radians about the screen origin.

    ###### Deprecated

  - ### rotateRadians

    public void rotateRadians(float angle)

    RRotates the coordinate system around a radian angle using the affine transform

    ###### Parameters

    - `angle`: the rotation angle in radians about graphics context's translated origin.

  - ### rotate

    public void rotate(float angle, int pivotX, int pivotY)

    Rotates the coordinate system around a radian angle using the affine transform

    ###### Parameters

    - `angle`: the rotation angle in radians

    - `pivotX`: the pivot point In absolute coordinates.

    - `pivotY`: the pivot point In absolute coordinates.

    ###### Deprecated

  - ### rotateRadians

    public void rotateRadians(float angle, int pivotX, int pivotY)

    Rotates the coordinate system around a radian angle using the affine transform

    ###### Parameters

    - `angle`: the rotation angle in radians

    - `pivotX`: the pivot point relative to the current graphics context's translation.

    - `pivotY`: the pivot point relative to the current graphics context's translation.

  - ### shear

    public void shear(float x, float y)

    Shear the graphics coordinate system using the affine transform

    ###### Parameters

    - `x`: shear factor for x

    - `y`: shear factor for y

  - ### beginNativeGraphicsAccess

    public Object beginNativeGraphicsAccess()

    Starts accessing the native graphics in the underlying OS, when accessing the native graphics Codename One shouldn't be used! The native graphics is unclipped and untranslated by default and its the responsibility of the caller to clip/translate appropriately.

    When finished with the native graphics it is essential to invoke endNativeGraphicsAccess

    ###### Returns

    an instance of the underlying native graphics object

  - ### endNativeGraphicsAccess

    public void endNativeGraphicsAccess()
    Invoke this to restore Codename One's graphics settings into the native graphics

  - ### tileImage

    public void tileImage(Image img, int x, int y, int w, int h)

    Allows an implementation to optimize image tiling rendering logic

    ###### Parameters

    - `img`: the image

    - `x`: coordinate to tile the image along

    - `y`: coordinate to tile the image along

    - `w`: coordinate to tile the image along

    - `h`: coordinate to tile the image along

  - ### getScaleX

    public float getScaleX()

    Returns the affine X scale

    ###### Returns

    the current scale

  - ### getScaleY

    public float getScaleY()

    Returns the affine Y scale

    ###### Returns

    the current scale

  - ### getRenderingHints

    public int getRenderingHints()

    Gets the current rendering hints for this context.

    ###### Returns

    The rendering hints.

    ###### See also

    - #RENDERING_HINT_FAST

  - ### setRenderingHints

    public void setRenderingHints(int hints)

    Sets rendering hints for this context.

    ###### Parameters

    - `hints`: int of rendering hints produced by logical AND on all applicable hints.

    ###### See also

    - #RENDERING_HINT_FAST

    - #getRenderingHints()