Graphics.java
上传用户:haobig99
上传日期:2022-06-15
资源大小:369k
文件大小:28k
源码类别:

J2ME

开发平台:

Java

  1. /*
  2.  * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4.  *
  5.  * This code is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License version 2 only, as
  7.  * published by the Free Software Foundation.  Sun designates this
  8.  * particular file as subject to the "Classpath" exception as provided
  9.  * by Sun in the LICENSE file that accompanied this code.
  10.  *
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * version 2 for more details (a copy is included in the LICENSE file that
  15.  * accompanied this code).
  16.  *
  17.  * You should have received a copy of the GNU General Public License version
  18.  * 2 along with this work; if not, write to the Free Software Foundation,
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20.  *
  21.  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22.  * CA 95054 USA or visit www.sun.com if you need additional information or
  23.  * have any questions.
  24.  */
  25. package com.sun.lwuit;
  26. import com.sun.lwuit.geom.Rectangle;
  27. import com.sun.lwuit.impl.LWUITImplementation;
  28. /**
  29.  * Abstracts the underlying platform graphics context thus allowing us to achieve
  30.  * portability between MIDP devices and CDC devices. This abstaction simplifies
  31.  * and unifies the Graphics implementations of various platforms.
  32.  * 
  33.  * <p>A graphics instance is never created by the developer and is always accessed
  34.  * using either a paint callback or a mutable image. There is no way to create this
  35.  * object directly.
  36.  */
  37. public final class Graphics {
  38.     private int xTranslate;
  39.     private int yTranslate;
  40.     private int color;
  41.     private Font current = Font.getDefaultFont();
  42.     private LWUITImplementation impl;
  43.     private Object nativeGraphics;
  44.     
  45.     
  46.     /**
  47.      * Constructing new graphics with a given javax.microedition.lcdui.Graphics 
  48.      * @param g a given javax.microedition.lcdui.Graphics
  49.      */
  50.     Graphics(Object nativeGraphics) {
  51.         setGraphics(nativeGraphics);
  52.         impl = Display.getInstance().getImplementation();
  53.     }
  54.     /**
  55.      * Setting graphics with a given javax.microedition.lcdui.Graphics
  56.      * 
  57.      * @param g a given javax.microedition.lcdui.Graphics
  58.      */
  59.     void setGraphics(Object g) {
  60.         this.nativeGraphics = g;
  61.     }
  62.     /**
  63.      * Returns javax.microedition.lcdui.Graphics
  64.      * 
  65.      * @return a javax.microedition.lcdui.Graphics object
  66.      */
  67.     Object getGraphics() {
  68.         return nativeGraphics;
  69.     }
  70.     /**
  71.      * Translates the X/Y location for drawing on the underlying surface. Translation
  72.      * is incremental so the new value will be added to the current translation and
  73.      * in order to reset translation we have to invoke 
  74.      * {@code translate(-getTranslateX(), -getTranslateY()) }
  75.      * 
  76.      * @param x the x coordinate
  77.      * @param y the y coordinate
  78.      */
  79.     public void translate(int x, int y) {
  80.         if(impl.isTranslationSupported()) {
  81.             impl.translate(nativeGraphics, x, y);
  82.         } else {
  83.             xTranslate += x;
  84.             yTranslate += y;
  85.         }
  86.     }
  87.     /**
  88.      * Returns the current x translate value 
  89.      * 
  90.      * @return the current x translate value 
  91.      */
  92.     public int getTranslateX() {
  93.         if(impl.isTranslationSupported()) {
  94.             return impl.getTranslateX(nativeGraphics);
  95.         } else {
  96.             return xTranslate;
  97.         }
  98.     }
  99.     /**
  100.      * Returns the current y translate value 
  101.      * 
  102.      * @return the current y translate value 
  103.      */
  104.     public int getTranslateY() {
  105.         if(impl.isTranslationSupported()) {
  106.             return impl.getTranslateY(nativeGraphics);
  107.         } else {
  108.             return yTranslate;
  109.         }
  110.     }
  111.     /**
  112.      * Returns the current color
  113.      * 
  114.      * @return the RGB graphics color 
  115.      */
  116.     public int getColor() {
  117.         return color;
  118.     }
  119.     /**
  120.      * Sets the current rgb color while ignoring any potential alpha component within
  121.      * said color value.
  122.      * 
  123.      * @param RGB the RGB value for the color.
  124.      */
  125.     public void setColor(int RGB) {
  126.         color = 0xffffff & RGB;
  127.         impl.setColor(nativeGraphics, color);
  128.     }
  129.     /**
  130.      * Returns the font used with the drawString method calls 
  131.      * 
  132.      * @return the font used with the drawString method calls
  133.      */
  134.     public Font getFont() {
  135.         return current;
  136.     }
  137.     /**
  138.      * Sets the font to use with the drawString method calls 
  139.      * 
  140.      * @param font the font used with the drawString method calls
  141.      */
  142.     public void setFont(Font font) {
  143.         this.current = font;
  144.         if(!(font instanceof CustomFont)) {
  145.             impl.setNativeFont(nativeGraphics, font.getNativeFont());
  146.         }
  147.     }
  148.     /**
  149.      * Returns the x clipping position
  150.      * 
  151.      * @return the x clipping position
  152.      */
  153.     public int getClipX() {
  154.         return impl.getClipX(nativeGraphics) - xTranslate;
  155.     }
  156.     /**
  157.      * Returns the y clipping position
  158.      * 
  159.      * @return the y clipping position
  160.      */
  161.     public int getClipY() {
  162.         return impl.getClipY(nativeGraphics) - yTranslate;
  163.     }
  164.     /**
  165.      * Returns the clip width
  166.      * 
  167.      * @return the clip width
  168.      */
  169.     public int getClipWidth() {
  170.         return impl.getClipWidth(nativeGraphics);
  171.     }
  172.     /**
  173.      * Returns the clip height
  174.      * 
  175.      * @return the clip height
  176.      */
  177.     public int getClipHeight() {
  178.         return impl.getClipHeight(nativeGraphics);
  179.     }
  180.     /**
  181.      * Clips the given rectangle by intersecting with the current clipping region, this
  182.      * method can thus only shrink the clipping region and never increase it.
  183.      * 
  184.      * @param x the x coordinate of the rectangle to intersect the clip with
  185.      * @param y the y coordinate of the rectangle to intersect the clip with
  186.      * @param width the width of the rectangle to intersect the clip with
  187.      * @param height the height of the rectangle to intersect the clip with
  188.      */
  189.     public void clipRect(int x, int y, int width, int height) {
  190.         impl.clipRect(nativeGraphics, xTranslate + x, yTranslate + y, width, height);
  191.     }
  192.     /**
  193.      * Updates the clipping region to match the given region exactly
  194.      * 
  195.      * @param x the x coordinate of the new clip rectangle.
  196.      * @param y the y coordinate of the new clip rectangle.
  197.      * @param width the width of the new clip rectangle.
  198.      * @param height the height of the new clip rectangle.
  199.      */
  200.     public void setClip(int x, int y, int width, int height) {
  201.         impl.setClip(nativeGraphics, xTranslate + x, yTranslate + y, width, height);
  202.     }
  203.     /**
  204.      * Draws a line between the 2 X/Y coordinates
  205.      * 
  206.      * @param x1 first x position
  207.      * @param y1 first y position
  208.      * @param x2 second x position
  209.      * @param y2 second y position
  210.      */
  211.     public void drawLine(int x1, int y1, int x2, int y2) {
  212.         impl.drawLine(nativeGraphics, xTranslate + x1, yTranslate + y1, xTranslate + x2, yTranslate + y2);
  213.     }
  214.     /**
  215.      * Fills the rectangle from the given position according to the width/height
  216.      * minus 1 pixel according to the convention in Java.
  217.      * 
  218.      * @param x the x coordinate of the rectangle to be filled.
  219.      * @param y the y coordinate of the rectangle to be filled.
  220.      * @param width the width of the rectangle to be filled.
  221.      * @param height the height of the rectangle to be filled.
  222.      */
  223.     public void fillRect(int x, int y, int width, int height) {
  224.         impl.fillRect(nativeGraphics, xTranslate + x, yTranslate + y, width, height);
  225.     }
  226.     /**
  227.      * Draws a rectangle in the given coordinates
  228.      * 
  229.      * @param x the x coordinate of the rectangle to be drawn.
  230.      * @param y the y coordinate of the rectangle to be drawn.
  231.      * @param width the width of the rectangle to be drawn.
  232.      * @param height the height of the rectangle to be drawn.
  233.      */
  234.     public void drawRect(int x, int y, int width, int height) {
  235.         impl.drawRect(nativeGraphics, xTranslate + x, yTranslate + y, width, height);
  236.     }
  237.     /**
  238.      * Draws a rounded corner rectangle in the given coordinates with the arcWidth/height
  239.      * matching the last two arguments respectively.
  240.      * 
  241.      * @param x the x coordinate of the rectangle to be drawn.
  242.      * @param y the y coordinate of the rectangle to be drawn.
  243.      * @param width the width of the rectangle to be drawn.
  244.      * @param height the height of the rectangle to be drawn.
  245.      * @param arcWidth the horizontal diameter of the arc at the four corners.
  246.      * @param arcHeight the vertical diameter of the arc at the four corners.
  247.      */
  248.     public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
  249.         impl.drawRoundRect(nativeGraphics, xTranslate + x, yTranslate + y, width, height, arcWidth, arcHeight);
  250.     }
  251.     /**
  252.      * Makes the current color slightly lighter, this is useful for many visual effects
  253.      * 
  254.      * @param factor the degree of lightening a color per channel a number from 1 to 255
  255.      */
  256.     public void lighterColor(int factor) {
  257.         int color = getColor();
  258.         int r = color >> 16 & 0xff;
  259.         int g = color >> 8 & 0xff;
  260.         int b = color & 0xff;
  261.         r = Math.min(0xff, r + factor);
  262.         g = Math.min(0xff, g + factor);
  263.         b = Math.min(0xff, b + factor);
  264.         setColor(((r << 16) & 0xff0000) | ((g << 8) & 0xff00) | (b & 0xff));
  265.     }
  266.     /**
  267.      * Makes the current color slightly darker, this is useful for many visual effects
  268.      * 
  269.      * @param factor the degree of lightening a color per channel a number from 1 to 255
  270.      */
  271.     public void darkerColor(int factor) {
  272.         int color = getColor();
  273.         int r = color >> 16 & 0xff;
  274.         int g = color >> 8 & 0xff;
  275.         int b = color & 0xff;
  276.         r = Math.max(0, r - factor);
  277.         g = Math.max(0, g - factor);
  278.         b = Math.max(0, b - factor);
  279.         setColor(((r << 16) & 0xff0000) | ((g << 8) & 0xff00) | (b & 0xff));
  280.     }
  281.     /**
  282.      * Fills a rounded rectangle in the same way as drawRoundRect
  283.      * 
  284.      * @param x the x coordinate of the rectangle to be filled.
  285.      * @param y the y coordinate of the rectangle to be filled.
  286.      * @param width the width of the rectangle to be filled.
  287.      * @param height the height of the rectangle to be filled.
  288.      * @param arcWidth the horizontal diameter of the arc at the four corners.
  289.      * @param arcHeight the vertical diameter of the arc at the four corners.
  290.      * @see #drawRoundRect
  291.      */
  292.     public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
  293.         impl.fillRoundRect(nativeGraphics, xTranslate + x, yTranslate + y, width, height, arcWidth, arcHeight);
  294.     }
  295.     /**
  296.      * Fills a circular or elliptical arc based on the given angles and bounding 
  297.      * box. The resulting arc begins at startAngle and extends for arcAngle 
  298.      * degrees.
  299.      * 
  300.      * @param x the x coordinate of the upper-left corner of the arc to be filled.
  301.      * @param y the y coordinate of the upper-left corner of the arc to be filled.
  302.      * @param width the width of the arc to be filled.
  303.      * @param height the height of the arc to be filled.
  304.      * @param startAngle the beginning angle.
  305.      * @param arcAngle the angular extent of the arc, relative to the start angle.
  306.      */
  307.     public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
  308.         impl.fillArc(nativeGraphics, xTranslate + x, yTranslate + y, width, height, startAngle, arcAngle);
  309.     }
  310.     /**
  311.      * Draws a circular or elliptical arc based on the given angles and bounding 
  312.      * box
  313.      * 
  314.      * @param x the x coordinate of the upper-left corner of the arc to be drawn.
  315.      * @param y the y coordinate of the upper-left corner of the arc to be drawn.
  316.      * @param width the width of the arc to be drawn.
  317.      * @param height the height of the arc to be drawn.
  318.      * @param startAngle the beginning angle.
  319.      * @param arcAngle the angular extent of the arc, relative to the start angle.
  320.      */
  321.     public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
  322.         impl.drawArc(nativeGraphics, xTranslate + x, yTranslate + y, width, height, startAngle, arcAngle);
  323.     }
  324.     /**
  325.      * Draw a string using the current font and color in the x,y coordinates. The font is drawn
  326.      * from the top position and not the baseline.
  327.      * 
  328.      * @param str the string to be drawn.
  329.      * @param x the x coordinate.
  330.      * @param y the y coordinate.
  331.      */
  332.     public void drawString(String str, int x, int y) {
  333.         if(!(current instanceof CustomFont)) {
  334.             impl.drawString(nativeGraphics, str, x + xTranslate, y + yTranslate);
  335.         } else {
  336.             char[] data = str.toCharArray();
  337.             current.drawChars(this, data, 0, data.length, x, y);
  338.         }
  339.     }
  340.     /**
  341.      * Draw the given char using the current font and color in the x,y 
  342.      * coordinates. The font is drawn from the top position and not the 
  343.      * baseline.
  344.      * 
  345.      * @param character - the character to be drawn
  346.      * @param x the x coordinate of the baseline of the text
  347.      * @param y the y coordinate of the baseline of the text
  348.      */
  349.     public void drawChar(char character, int x, int y) {
  350.         drawString("" + character, x, y);
  351.     }
  352.     /**
  353.      * Draw the given char array using the current font and color in the x,y coordinates. The font is drawn
  354.      * from the top position and not the baseline.
  355.      * 
  356.      * @param data the array of characters to be drawn
  357.      * @param offset the start offset in the data
  358.      * @param length the number of characters to be drawn
  359.      * @param x the x coordinate of the baseline of the text
  360.      * @param y the y coordinate of the baseline of the text
  361.      */
  362.     public void drawChars(char[] data, int offset, int length, int x, int y) {
  363.         if(!(current instanceof CustomFont)) {
  364.             drawString(new String(data, offset, length), x, y);
  365.         } else {
  366.             CustomFont f = (CustomFont)current;
  367.             f.drawChars(this, data, offset, length, x, y);
  368.         }
  369.     }
  370.     /**
  371.      * Draws the image so its top left coordinate corresponds to x/y
  372.      * 
  373.      * @param img the specified image to be drawn. This method does 
  374.      * nothing if img is null.
  375.      * @param x the x coordinate.
  376.      * @param y the y coordinate.
  377.      */
  378.     public void drawImage(Image img, int x, int y) {
  379.         img.drawImage(this, nativeGraphics, x, y);
  380.     }
  381.     void drawImage(Object img, int x, int y) {
  382.         impl.drawImage(nativeGraphics, img, x + xTranslate, y + yTranslate);
  383.     }
  384.     /**
  385.      * Draws an image with a MIDP trasnform for fast rotation
  386.      */
  387.     void drawImage(Object img, int x, int y, int transform) {
  388.         if (transform != 0) {
  389.             impl.drawImageRotated(nativeGraphics, img, x + xTranslate, y + yTranslate, transform);
  390.         } else {
  391.             drawImage(img, x, y);
  392.         }
  393.     }
  394.     /**
  395.      * Draws a filled triangle with the given coordinates
  396.      * 
  397.      * @param x1 the x coordinate of the first vertex of the triangle
  398.      * @param y1 the y coordinate of the first vertex of the triangle
  399.      * @param x2 the x coordinate of the second vertex of the triangle
  400.      * @param y2 the y coordinate of the second vertex of the triangle
  401.      * @param x3 the x coordinate of the third vertex of the triangle
  402.      * @param y3 the y coordinate of the third vertex of the triangle
  403.      */
  404.     public void fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3) {
  405.         impl.fillTriangle(nativeGraphics, xTranslate + x1, yTranslate + y1, xTranslate + x2, yTranslate + y2, xTranslate + x3, yTranslate + y3);
  406.     }
  407.     /**
  408.      * Draws the RGB values based on the MIDP API of a similar name. Renders a 
  409.      * series of device-independent RGB+transparency values in a specified 
  410.      * region. The values are stored in rgbData in a format with 24 bits of 
  411.      * RGB and an eight-bit alpha value (0xAARRGGBB), with the first value 
  412.      * stored at the specified offset. The scanlength  specifies the relative 
  413.      * offset within the array between the corresponding pixels of consecutive 
  414.      * rows. Any value for scanlength is acceptable (even negative values) 
  415.      * provided that all resulting references are within the bounds of the 
  416.      * rgbData array. The ARGB data is rasterized horizontally from left to 
  417.      * right within each row. The ARGB values are rendered in the region 
  418.      * specified by x, y, width and height, and the operation is subject 
  419.      * to the current clip region and translation for this Graphics object.
  420.      * 
  421.      * @param rgbData an array of ARGB values in the format 0xAARRGGBB
  422.      * @param offset the array index of the first ARGB value
  423.      * @param x the horizontal location of the region to be rendered
  424.      * @param y the vertical location of the region to be rendered
  425.      * @param w the width of the region to be rendered
  426.      * @param h the height of the region to be rendered
  427.      * @param processAlpha true if rgbData has an alpha channel, false if
  428.      * all pixels are fully opaque
  429.      */
  430.     void drawRGB(int[] rgbData, int offset, int x, int y, int w, int h, boolean processAlpha) {
  431.         impl.drawRGB(nativeGraphics, rgbData, offset, x + xTranslate, y + yTranslate, w, h, processAlpha);
  432.     }
  433.     /**
  434.      * Draws a radial gradient in the given coordinates with the given colors, 
  435.      * doesn't take alpha into consideration when drawing the gradient.
  436.      * Notice that a radial gradient will result in a circular shape, to create
  437.      * a square use fillRect or draw a larger shape and clip to the appropriate size.
  438.      * 
  439.      * @param startColor the starting RGB color
  440.      * @param endColor  the ending RGB color
  441.      * @param x the x coordinate
  442.      * @param y the y coordinate
  443.      * @param width the width of the region to be filled
  444.      * @param height the height of the region to be filled
  445.      */
  446.     public void fillRadialGradient(int startColor, int endColor, int x, int y, int width, int height) {
  447.         impl.fillRadialGradient(nativeGraphics, startColor, endColor, x + xTranslate, y + yTranslate, width, height);
  448.     }
  449.     /**
  450.      * Draws a radial gradient in the given coordinates with the given colors,
  451.      * doesn't take alpha into consideration when drawing the gradient. Notice that this method
  452.      * differs from fillRadialGradient since it draws a sqare gradient at all times
  453.      * and can thus be cached
  454.      * Notice that a radial gradient will result in a circular shape, to create
  455.      * a square use fillRect or draw a larger shape and clip to the appropriate size.
  456.      *
  457.      * @param startColor the starting RGB color
  458.      * @param endColor  the ending RGB color
  459.      * @param x the x coordinate
  460.      * @param y the y coordinate
  461.      * @param width the width of the region to be filled
  462.      * @param height the height of the region to be filled
  463.      * @param relativeX indicates the relative position of the gradient within the drawing region
  464.      * @param relativeY indicates the relative position of the gradient within the drawing region
  465.      * @param relativeSize  indicates the relative size of the gradient within the drawing region
  466.      */
  467.     public void fillRectRadialGradient(int startColor, int endColor, int x, int y, int width, int height, float relativeX, float relativeY, float relativeSize) {
  468.         impl.fillRectRadialGradient(nativeGraphics, startColor, endColor, x + xTranslate, y + yTranslate, width, height, relativeX, relativeY, relativeSize);
  469.     }
  470.     /**
  471.      * Draws a linear gradient in the given coordinates with the given colors, 
  472.      * doesn't take alpha into consideration when drawing the gradient
  473.      * 
  474.      * @param startColor the starting RGB color
  475.      * @param endColor  the ending RGB color
  476.      * @param x the x coordinate
  477.      * @param y the y coordinate
  478.      * @param width the width of the region to be filled
  479.      * @param height the height of the region to be filled
  480.      * @param horizontal indicating wheter it is a horizontal fill or vertical
  481.      */
  482.     public void fillLinearGradient(int startColor, int endColor, int x, int y, int width, int height, boolean horizontal) {
  483.         impl.fillLinearGradient(nativeGraphics, startColor, endColor, x + xTranslate, y + yTranslate, width, height, horizontal);
  484.     }
  485.     /**
  486.      * Fills a rectangle with an optionally translucent fill color
  487.      * 
  488.      * @param x the x coordinate of the rectangle to be filled
  489.      * @param y the y coordinate of the rectangle to be filled
  490.      * @param w the width of the rectangle to be filled
  491.      * @param h the height of the rectangle to be filled
  492.      * @param alpha the alpha values specify semitransparency
  493.      */
  494.     public void fillRect(int x, int y, int w, int h, byte alpha) {
  495.         if(alpha != 0) {
  496.             int oldAlpha = impl.getAlpha(nativeGraphics);
  497.             impl.setAlpha(nativeGraphics, alpha & 0xff);
  498.             impl.fillRect(nativeGraphics, x + xTranslate, y + yTranslate, w, h);
  499.             impl.setAlpha(nativeGraphics, oldAlpha);
  500.         }
  501.     }
  502.     /**
  503.      *  Fills a closed polygon defined by arrays of x and y coordinates. 
  504.      *  Each pair of (x, y) coordinates defines a point.
  505.      * 
  506.      *  @param xPoints - a an array of x coordinates.
  507.      *  @param yPoints - a an array of y coordinates.
  508.      *  @param nPoints - a the total number of points.
  509.      */
  510.     public void fillPolygon(int[] xPoints,
  511.             int[] yPoints,
  512.             int nPoints) {
  513.         int[] cX = xPoints;
  514.         int[] cY = yPoints;
  515.         if((!impl.isTranslationSupported()) && (xTranslate != 0 || yTranslate != 0)) {
  516.             cX = new int[nPoints];
  517.             cY = new int[nPoints];
  518.             System.arraycopy(xPoints, 0, cX, 0, nPoints);
  519.             System.arraycopy(yPoints, 0, cY, 0, nPoints);
  520.             for(int iter = 0 ; iter < nPoints ; iter++) {
  521.                 cX[iter] += xTranslate;
  522.                 cY[iter] += yTranslate;
  523.             }
  524.         }
  525.         impl.fillPolygon(nativeGraphics, cX, cY, nPoints);
  526.     }
  527.     /**
  528.      * Draws a region of an image in the given x/y coordinate
  529.      * 
  530.      * @param img the image to draw
  531.      * @param x x location for the image
  532.      * @param y y location for the image
  533.      * @param imageX location within the image to draw
  534.      * @param imageY location within the image to draw
  535.      * @param imageWidth size of the location within the image to draw
  536.      * @param imageHeight size of the location within the image to draw
  537.      */
  538.     void drawImageArea(Image img, int x, int y, int imageX, int imageY, int imageWidth, int imageHeight) {
  539.         img.drawImageArea(this, nativeGraphics, x, y, imageX, imageY, imageWidth, imageHeight);
  540.     }
  541.     /**
  542.      *  Draws a closed polygon defined by arrays of x and y coordinates. 
  543.      *  Each pair of (x, y) coordinates defines a point.
  544.      * 
  545.      *  @param xPoints - a an array of x coordinates.
  546.      *  @param yPoints - a an array of y coordinates.
  547.      *  @param nPoints - a the total number of points.
  548.      */
  549.     public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) {
  550.         int[] cX = xPoints;
  551.         int[] cY = yPoints;
  552.         if((!impl.isTranslationSupported()) && (xTranslate != 0 || yTranslate != 0)) {
  553.             cX = new int[nPoints];
  554.             cY = new int[nPoints];
  555.             System.arraycopy(xPoints, 0, cX, 0, nPoints);
  556.             System.arraycopy(yPoints, 0, cY, 0, nPoints);
  557.             for(int iter = 0 ; iter < nPoints ; iter++) {
  558.                 cX[iter] += xTranslate;
  559.                 cY[iter] += yTranslate;
  560.             }
  561.         }
  562.         impl.drawPolygon(nativeGraphics, cX, cY, nPoints);
  563.     }
  564.     
  565.     /**
  566.      * Indicates whether invoking set/getAlpha would have an effect on all further
  567.      * rendering from this graphics object.
  568.      * 
  569.      * @return false if setAlpha has no effect true if it applies to everything some effect
  570.      */
  571.     public boolean isAlphaSupported() {
  572.        return impl.isAlphaGlobal(); 
  573.     }
  574.     
  575.     /**
  576.      * Sets alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque
  577.      * and 0 is completely transparent
  578.      * 
  579.      * @param a the alpha value
  580.      */
  581.     public void setAlpha(int a) {
  582.         impl.setAlpha(nativeGraphics, a);
  583.     }
  584.     
  585.     /**
  586.      * Returnes the alpha as a value between 0-255 (0 - 0xff) where 255 is completely opaque
  587.      * and 0 is completely transparent
  588.      * 
  589.      * @return the alpha value
  590.      */
  591.     public int getAlpha() {
  592.         return impl.getAlpha(nativeGraphics);
  593.     }
  594.     
  595.     /**
  596.      * Returns true if anti-aliasing for standard rendering operations is supported,
  597.      * notice that text anti-aliasing is a separate attribute.
  598.      * 
  599.      * @return true if anti aliasing is supported
  600.      */
  601.     public boolean isAntiAliasingSupported() {
  602.         return impl.isAntiAliasingSupported();
  603.     }
  604.     
  605.     /**
  606.      * Returns true if anti-aliasing for text is supported,
  607.      * notice that text anti-aliasing is a separate attribute from standard anti-alisaing.
  608.      * 
  609.      * @return true if text anti aliasing is supported
  610.      */
  611.     public boolean isAntiAliasedTextSupported() {
  612.         return impl.isAntiAliasedTextSupported();
  613.     }
  614.     
  615.     /**
  616.      * Returns true if anti-aliasing for standard rendering operations is turned on.
  617.      * 
  618.      * @return true if anti aliasing is active
  619.      */
  620.     public boolean isAntiAliased() {
  621.         return impl.isAntiAliased(nativeGraphics);
  622.     }
  623.     /**
  624.      * Set whether anti-aliasing for standard rendering operations is turned on.
  625.      * 
  626.      * @param a true if anti aliasing is active
  627.      */
  628.     public void setAntiAliased(boolean a) {
  629.         impl.setAntiAliased(nativeGraphics, a);
  630.     }
  631.     
  632.     /**
  633.      * Set whether anti-aliasing for text is active,
  634.      * notice that text anti-aliasing is a separate attribute from standard anti-alisaing.
  635.      * 
  636.      * @param a true if text anti aliasing is supported
  637.      */
  638.     public void setAntiAliasedText(boolean a) {
  639.         impl.setAntiAliasedText(nativeGraphics, a);
  640.     }
  641.     
  642.     /**
  643.      * Indicates whether anti-aliasing for text is active,
  644.      * notice that text anti-aliasing is a separate attribute from standard anti-alisaing.
  645.      * 
  646.      * @return true if text anti aliasing is supported
  647.      */
  648.     public boolean isAntiAliasedText(boolean a) {
  649.         return impl.isAntiAliasedText(nativeGraphics);
  650.     }
  651.     /**
  652.      * Indicates whether the underlying implementation can draw using an affine
  653.      * transform hence methods such as rotate, scale and shear would work
  654.      *
  655.      * @return true if an affine transformation matrix is present
  656.      */
  657.     public boolean isAffineSupported() {
  658.         return impl.isAffineSupported();
  659.     }
  660.     /**
  661.      * Resets the affine transform to the default value
  662.      */
  663.     public void resetAffine() {
  664.         impl.resetAffine(nativeGraphics);
  665.     }
  666.     /**
  667.      * Scales the coordinate system using the affine transform
  668.      *
  669.      * @param scale factor for x
  670.      * @param scale factor for y
  671.      */
  672.     public void scale(float x, float y) {
  673.         impl.scale(nativeGraphics, x, y);
  674.     }
  675.     /**
  676.      * Rotates the coordinate system around a radian angle using the affine transform
  677.      *
  678.      * @param angle the rotation angle in radians
  679.      */
  680.     public void rotate(float angle) {
  681.         impl.rotate(nativeGraphics, angle);
  682.     }
  683.     /**
  684.      * Shear the graphics coordinate system using the affine transform
  685.      *
  686.      * @param shear factor for x
  687.      * @param shear factor for y
  688.      * @param nativeGraphics the native graphics object
  689.      */
  690.     public void shear(float x, float y) {
  691.         impl.shear(nativeGraphics, x, y);
  692.     }
  693. }