| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Alexey A. Petrenko |
| * @version $Revision$ |
| */ |
| |
| package java.awt; |
| |
| import java.awt.image.ImageObserver; |
| import java.text.AttributedCharacterIterator; |
| |
| /** |
| * The abstract Graphics class allows applications to draw on a screen or other |
| * rendering target. There are several properties which define rendering |
| * options: origin point, clipping area, color, font. <br> |
| * <br> |
| * The origin point specifies the beginning of the clipping area coordinate |
| * system. All coordinates used in rendering operations are computed with |
| * respect to this point. The clipping area defines the boundaries where |
| * rendering operations can be performed. Rendering operations can't modify |
| * pixels outside of the clipping area. <br> |
| * <br> |
| * The draw and fill methods allow applications to drawing shapes, text, images |
| * with specified font and color options in the specified part of the screen. |
| * |
| * @since Android 1.0 |
| */ |
| public abstract class Graphics { |
| |
| // Constructors |
| |
| /** |
| * Instantiates a new Graphics. This constructor is default for Graphics and |
| * can not be called directly. |
| */ |
| protected Graphics() { |
| } |
| |
| // Public methods |
| |
| /** |
| * Creates a copy of the Graphics object with a new origin and a new |
| * specified clip area. The new clip area is the rectangle defined by the |
| * origin point with coordinates X,Y and the given width and height. The |
| * coordinates of all subsequent rendering operations will be computed with |
| * respect to the new origin and can be performed only within the range of |
| * the clipping area dimensions. |
| * |
| * @param x |
| * the X coordinate of the original point. |
| * @param y |
| * the Y coordinate of the original point. |
| * @param width |
| * the width of clipping area. |
| * @param height |
| * the height of clipping area. |
| * @return the Graphics object with new origin point and clipping area. |
| */ |
| public Graphics create(int x, int y, int width, int height) { |
| Graphics res = create(); |
| res.translate(x, y); |
| res.clipRect(0, 0, width, height); |
| return res; |
| } |
| |
| /** |
| * Draws the highlighted outline of a rectangle. |
| * |
| * @param x |
| * the X coordinate of the rectangle's top left corner. |
| * @param y |
| * the Y coordinate of the rectangle's top left corner. |
| * @param width |
| * the width of rectangle. |
| * @param height |
| * the height of rectangle. |
| * @param raised |
| * a boolean value that determines whether the rectangle is drawn |
| * as raised or indented. |
| */ |
| public void draw3DRect(int x, int y, int width, int height, boolean raised) { |
| // Note: lighter/darker colors should be used to draw 3d rect. |
| // The resulting rect is (width+1)x(height+1). Stroke and paint |
| // attributes of |
| // the Graphics2D should be reset to the default values. |
| // fillRect is used instead of drawLine to bypass stroke |
| // reset/set and rasterization. |
| |
| Color color = getColor(); |
| Color colorUp, colorDown; |
| if (raised) { |
| colorUp = color.brighter(); |
| colorDown = color.darker(); |
| } else { |
| colorUp = color.darker(); |
| colorDown = color.brighter(); |
| } |
| |
| setColor(colorUp); |
| fillRect(x, y, width, 1); |
| fillRect(x, y + 1, 1, height); |
| |
| setColor(colorDown); |
| fillRect(x + width, y, 1, height); |
| fillRect(x + 1, y + height, width, 1); |
| } |
| |
| /** |
| * Draws the text represented by byte array. This method uses the current |
| * font and color for rendering. |
| * |
| * @param bytes |
| * the byte array which contains the text to be drawn. |
| * @param off |
| * the offset within the byte array of the text to be drawn. |
| * @param len |
| * the number of bytes of text to draw. |
| * @param x |
| * the X coordinate where the text is to be drawn. |
| * @param y |
| * the Y coordinate where the text is to be drawn. |
| */ |
| public void drawBytes(byte[] bytes, int off, int len, int x, int y) { |
| drawString(new String(bytes, off, len), x, y); |
| } |
| |
| /** |
| * Draws the text represented by character array. This method uses the |
| * current font and color for rendering. |
| * |
| * @param chars |
| * the character array. |
| * @param off |
| * the offset within the character array of the text to be drawn. |
| * @param len |
| * the number of characters which will be drawn. |
| * @param x |
| * the X coordinate where the text is to be drawn. |
| * @param y |
| * the Y coordinate where the text is to be drawn. |
| */ |
| public void drawChars(char[] chars, int off, int len, int x, int y) { |
| drawString(new String(chars, off, len), x, y); |
| } |
| |
| /** |
| * Draws the outline of a polygon which is defined by Polygon object. |
| * |
| * @param p |
| * the Polygon object. |
| */ |
| public void drawPolygon(Polygon p) { |
| drawPolygon(p.xpoints, p.ypoints, p.npoints); |
| } |
| |
| /** |
| * Draws the rectangle with the specified width and length and top left |
| * corner coordinates. |
| * |
| * @param x |
| * the X coordinate of the rectangle's top left corner. |
| * @param y |
| * the Y coordinate of the rectangle's top left corner. |
| * @param width |
| * the width of the rectangle. |
| * @param height |
| * the height of the rectangle. |
| */ |
| public void drawRect(int x, int y, int width, int height) { |
| int[] xpoints = { |
| x, x, x + width, x + width |
| }; |
| int[] ypoints = { |
| y, y + height, y + height, y |
| }; |
| |
| drawPolygon(xpoints, ypoints, 4); |
| } |
| |
| /** |
| * Fills the highlighted outline of a rectangle. |
| * |
| * @param x |
| * the X coordinate of the rectangle's top left corner. |
| * @param y |
| * the Y coordinate of the rectangle's top left corner. |
| * @param width |
| * the width of the rectangle. |
| * @param height |
| * the height of the rectangle. |
| * @param raised |
| * a boolean value that determines whether the rectangle is drawn |
| * as raised or indented. |
| */ |
| public void fill3DRect(int x, int y, int width, int height, boolean raised) { |
| // Note: lighter/darker colors should be used to draw 3d rect. |
| // The resulting rect is (width)x(height), same as fillRect. |
| // Stroke and paint attributes of the Graphics2D should be reset |
| // to the default values. fillRect is used instead of drawLine to |
| // bypass stroke reset/set and line rasterization. |
| |
| Color color = getColor(); |
| Color colorUp, colorDown; |
| if (raised) { |
| colorUp = color.brighter(); |
| colorDown = color.darker(); |
| setColor(color); |
| } else { |
| colorUp = color.darker(); |
| colorDown = color.brighter(); |
| setColor(colorUp); |
| } |
| |
| width--; |
| height--; |
| fillRect(x + 1, y + 1, width - 1, height - 1); |
| |
| setColor(colorUp); |
| fillRect(x, y, width, 1); |
| fillRect(x, y + 1, 1, height); |
| |
| setColor(colorDown); |
| fillRect(x + width, y, 1, height); |
| fillRect(x + 1, y + height, width, 1); |
| } |
| |
| /** |
| * Fills the polygon with the current color. |
| * |
| * @param p |
| * the Polygon object. |
| */ |
| public void fillPolygon(Polygon p) { |
| fillPolygon(p.xpoints, p.ypoints, p.npoints); |
| } |
| |
| /** |
| * Disposes of the Graphics. |
| */ |
| @Override |
| public void finalize() { |
| } |
| |
| /** |
| * Gets the bounds of the current clipping area as a rectangle and copies it |
| * to an existing rectangle. |
| * |
| * @param r |
| * a Rectangle object where the current clipping area bounds are |
| * to be copied. |
| * @return the bounds of the current clipping area. |
| */ |
| public Rectangle getClipBounds(Rectangle r) { |
| Shape clip = getClip(); |
| |
| if (clip != null) { |
| // TODO: Can we get shape bounds without creating Rectangle object? |
| Rectangle b = clip.getBounds(); |
| r.x = b.x; |
| r.y = b.y; |
| r.width = b.width; |
| r.height = b.height; |
| } |
| |
| return r; |
| } |
| |
| /** |
| * Gets the bounds of the current clipping area as a rectangle. |
| * |
| * @return a Rectangle object. |
| * @deprecated Use {@link #getClipBounds()} |
| */ |
| @Deprecated |
| public Rectangle getClipRect() { |
| return getClipBounds(); |
| } |
| |
| /** |
| * Gets the font metrics of the current font. The font metrics object |
| * contains information about the rendering of a particular font. |
| * |
| * @return the font metrics of current font. |
| */ |
| public FontMetrics getFontMetrics() { |
| return getFontMetrics(getFont()); |
| } |
| |
| /** |
| * Determines whether or not the specified rectangle intersects the current |
| * clipping area. |
| * |
| * @param x |
| * the X coordinate of the rectangle. |
| * @param y |
| * the Y coordinate of the rectangle. |
| * @param width |
| * the width of the rectangle. |
| * @param height |
| * the height of the rectangle. |
| * @return true, if the specified rectangle intersects the current clipping |
| * area, false otherwise. |
| */ |
| public boolean hitClip(int x, int y, int width, int height) { |
| // TODO: Create package private method Rectangle.intersects(int, int, |
| // int, int); |
| return getClipBounds().intersects(new Rectangle(x, y, width, height)); |
| } |
| |
| /** |
| * Returns string which represents this Graphics object. |
| * |
| * @return the string which represents this Graphics object. |
| */ |
| @Override |
| public String toString() { |
| // TODO: Think about string representation of Graphics. |
| return "Graphics"; //$NON-NLS-1$ |
| } |
| |
| // Abstract methods |
| |
| /** |
| * Clears the specified rectangle. This method fills specified rectangle |
| * with background color. |
| * |
| * @param x |
| * the X coordinate of the rectangle. |
| * @param y |
| * the Y coordinate of the rectangle. |
| * @param width |
| * the width of the rectangle. |
| * @param height |
| * the height of the rectangle. |
| */ |
| public abstract void clearRect(int x, int y, int width, int height); |
| |
| /** |
| * Intersects the current clipping area with a new rectangle. If the current |
| * clipping area is not defined, the rectangle becomes a new clipping area. |
| * Rendering operations are only allowed within the new the clipping area. |
| * |
| * @param x |
| * the X coordinate of the rectangle for intersection. |
| * @param y |
| * the Y coordinate of the rectangle for intersection. |
| * @param width |
| * the width of the rectangle for intersection. |
| * @param height |
| * the height of the rectangle for intersection. |
| */ |
| public abstract void clipRect(int x, int y, int width, int height); |
| |
| /** |
| * Copies the rectangle area to another area specified by a distance (dx, |
| * dy) from the original rectangle's location. Positive dx and dy values |
| * give a new location defined by translation to the right and down from the |
| * original location, negative dx and dy values - to the left and up. |
| * |
| * @param sx |
| * the X coordinate of the rectangle which will be copied. |
| * @param sy |
| * the Y coordinate of the rectangle which will be copied. |
| * @param width |
| * the width of the rectangle which will be copied. |
| * @param height |
| * the height of the rectangle which will be copied. |
| * @param dx |
| * the horizontal distance from the source rectangle's location |
| * to the copy's location. |
| * @param dy |
| * the vertical distance from the source rectangle's location to |
| * the copy's location. |
| */ |
| public abstract void copyArea(int sx, int sy, int width, int height, int dx, int dy); |
| |
| /** |
| * Creates a new copy of this Graphics. |
| * |
| * @return a new Graphics context which is a copy of this Graphics. |
| */ |
| public abstract Graphics create(); |
| |
| /** |
| * Disposes of the Graphics. This Graphics object can not be used after |
| * calling this method. |
| */ |
| public abstract void dispose(); |
| |
| /** |
| * Draws the arc covering the specified rectangle and using the current |
| * color. The rectangle is defined by the origin point (X, Y) and dimensions |
| * (width and height). The arc center is the the center of specified |
| * rectangle. The angle origin is 3 o'clock position, the positive angle is |
| * counted as a counter-clockwise rotation, the negative angle is counted as |
| * clockwise rotation. |
| * |
| * @param x |
| * the X origin coordinate of the rectangle which scales the arc. |
| * @param y |
| * the Y origin coordinate of the rectangle which scales the arc. |
| * @param width |
| * the width of the rectangle which scales the arc. |
| * @param height |
| * the height of the rectangle which scales the arc. |
| * @param sa |
| * start angle - the origin angle of arc. |
| * @param ea |
| * arc angle - the angular arc value relative to the start angle. |
| */ |
| public abstract void drawArc(int x, int y, int width, int height, int sa, int ea); |
| |
| /** |
| * Draws the specified image with the defined background color. The top left |
| * corner of image will be drawn at point (x, y) in current coordinate |
| * system. The image loading process notifies the specified Image Observer. |
| * This method returns true if the image has loaded, otherwise it returns |
| * false. |
| * |
| * @param img |
| * the image which will be drawn. |
| * @param x |
| * the X coordinate of the image top left corner. |
| * @param y |
| * the Y coordinate of the image top left corner. |
| * @param bgcolor |
| * the background color. |
| * @param observer |
| * the ImageObserver object which should be notified about image |
| * loading process. |
| * @return true, if loading image is successful or image is null, false |
| * otherwise. |
| */ |
| public abstract boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer); |
| |
| /** |
| * Draws the specified image. The top left corner of image will be drawn at |
| * point (x, y) in current coordinate system. The image loading process |
| * notifies the specified Image Observer. This method returns true if the |
| * image has loaded, otherwise it returns false. |
| * |
| * @param img |
| * the image which will be drawn. |
| * @param x |
| * the X coordinate of the image top left corner. |
| * @param y |
| * the Y coordinate of the image top left corner. |
| * @param observer |
| * the ImageObserver object which should be notified about image |
| * loading process. |
| * @return true, if loading image is successful or image is null, otherwise |
| * false. |
| */ |
| public abstract boolean drawImage(Image img, int x, int y, ImageObserver observer); |
| |
| /** |
| * Scales the specified image to fit in the specified rectangle and draws it |
| * with the defined background color. The top left corner of the image will |
| * be drawn at the point (x, y) in current coordinate system. The non-opaque |
| * pixels will be drawn in the background color. The image loading process |
| * notifies the specified Image Observer. This method returns true if the |
| * image has loaded, otherwise it returns false. |
| * |
| * @param img |
| * the image which will be drawn. |
| * @param x |
| * the X coordinate of the image's top left corner. |
| * @param y |
| * the Y coordinate of the image's top left corner. |
| * @param width |
| * the width of rectangle which scales the image. |
| * @param height |
| * the height of rectangle which scales the image. |
| * @param bgcolor |
| * the background color. |
| * @param observer |
| * the ImageObserver object which should be notified about image |
| * loading process. |
| * @return true, if loading image is successful or image is null, otherwise |
| * false. |
| */ |
| public abstract boolean drawImage(Image img, int x, int y, int width, int height, |
| Color bgcolor, ImageObserver observer); |
| |
| /** |
| * Scales the specified image to fit in the specified rectangle and draws |
| * it. The top left corner of the image will be drawn at the point (x, y) in |
| * current coordinate system. The image loading process notifies the |
| * specified Image Observer. This method returns true if the image has |
| * loaded, otherwise it returns false. |
| * |
| * @param img |
| * the image which will be drawn. |
| * @param x |
| * the X coordinate of the image top left corner. |
| * @param y |
| * the Y coordinate of the image top left corner. |
| * @param width |
| * the width of rectangle which scales the image. |
| * @param height |
| * the height of rectangle which scales the image. |
| * @param observer |
| * the ImageObserver object which should be notified about image |
| * loading process. |
| * @return true, if loading image is successful or image is null, otherwise |
| * false. |
| */ |
| public abstract boolean drawImage(Image img, int x, int y, int width, int height, |
| ImageObserver observer); |
| |
| /** |
| * Scales the specified area of the specified image to fit in the rectangle |
| * area defined by its corners coordinates and draws the sub-image with the |
| * specified background color. The sub-image to be drawn is defined by its |
| * top left corner coordinates (sx1, sy1) and bottom right corner |
| * coordinates (sx2, sy2) computed with respect to the origin (top left |
| * corner) of the source image. The non opaque pixels will be drawn in the |
| * background color. The image loading process notifies specified Image |
| * Observer. This method returns true if the image has loaded, otherwise it |
| * returns false. |
| * |
| * @param img |
| * the image which will be drawn. |
| * @param dx1 |
| * the X top left corner coordinate of the destination rectangle |
| * area. |
| * @param dy1 |
| * the Y top left corner coordinate of the destination rectangle |
| * area. |
| * @param dx2 |
| * the X bottom right corner coordinate of the destination |
| * rectangle area. |
| * @param dy2 |
| * the Y bottom right corner coordinate of the destination |
| * rectangle area. |
| * @param sx1 |
| * the X top left corner coordinate of the area to be drawn |
| * within the source image. |
| * @param sy1 |
| * the Y top left corner coordinate of the area to be drawn |
| * within the source image. |
| * @param sx2 |
| * the X bottom right corner coordinate of the area to be drawn |
| * within the source image. |
| * @param sy2 |
| * the Y bottom right corner coordinate of the area to be drawn |
| * within the source image. |
| * @param bgcolor |
| * the background color. |
| * @param observer |
| * the ImageObserver object which should be notified about image |
| * loading process. |
| * @return true, if loading image is successful or image is null, false |
| * otherwise. |
| */ |
| public abstract boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, |
| int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer); |
| |
| /** |
| * Scales the specified area of the specified image to fit in the rectangle |
| * area defined by its corners coordinates and draws the sub-image. The |
| * sub-image to be drawn is defined by its top left corner coordinates (sx1, |
| * sy1) and bottom right corner coordinates (sx2, sy2) computed with respect |
| * to the origin (top left corner) of the source image. The image loading |
| * process notifies specified Image Observer. This method returns true if |
| * the image has loaded, otherwise it returns false. |
| * |
| * @param img |
| * the image which will be drawn. |
| * @param dx1 |
| * the X top left corner coordinate of the destination rectangle |
| * area. |
| * @param dy1 |
| * the Y top left corner coordinate of the destination rectangle |
| * area. |
| * @param dx2 |
| * the X bottom right corner coordinate of the destination |
| * rectangle area. |
| * @param dy2 |
| * the Y bottom right corner coordinate of the destination |
| * rectangle area. |
| * @param sx1 |
| * the X top left corner coordinate of the area to be drawn |
| * within the source image. |
| * @param sy1 |
| * the Y top left corner coordinate of the area to be drawn |
| * within the source image. |
| * @param sx2 |
| * the X bottom right corner coordinate of the area to be drawn |
| * within the source image. |
| * @param sy2 |
| * the Y bottom right corner coordinate of the area to be drawn |
| * within the source image. |
| * @param observer |
| * the ImageObserver object which should be notified about image |
| * loading process. |
| * @return true, if loading image is successful or image is null, false |
| * otherwise. |
| */ |
| public abstract boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, |
| int sy1, int sx2, int sy2, ImageObserver observer); |
| |
| /** |
| * Draws a line from the point (x1, y1) to the point (x2, y2). This method |
| * draws the line with current color which can be changed by setColor(Color |
| * c) method. |
| * |
| * @param x1 |
| * the X coordinate of the first point. |
| * @param y1 |
| * the Y coordinate of the first point. |
| * @param x2 |
| * the X coordinate of the second point. |
| * @param y2 |
| * the Y coordinate of the second point. |
| */ |
| public abstract void drawLine(int x1, int y1, int x2, int y2); |
| |
| /** |
| * Draws the outline of an oval to fit in the rectangle defined by the given |
| * width, height, and top left corner. |
| * |
| * @param x |
| * the X top left corner oval coordinate. |
| * @param y |
| * the Y top left corner oval coordinate. |
| * @param width |
| * the oval width. |
| * @param height |
| * the oval height. |
| */ |
| public abstract void drawOval(int x, int y, int width, int height); |
| |
| /** |
| * Draws the outline of a polygon. The polygon vertices are defined by |
| * points with xpoints[i], ypoints[i] as coordinates. The polygon edges are |
| * the lines from the points with (xpoints[i-1], ypoints[i-1]) coordinates |
| * to the points with (xpoints[i], ypoints[i]) coordinates, for 0 < i < |
| * npoints +1. |
| * |
| * @param xpoints |
| * the array of X coordinates of the polygon vertices. |
| * @param ypoints |
| * the array of Y coordinates of the polygon vertices. |
| * @param npoints |
| * the number of polygon vertices/points. |
| */ |
| public abstract void drawPolygon(int[] xpoints, int[] ypoints, int npoints); |
| |
| /** |
| * Draws a set of connected lines which are defined by the x and y |
| * coordinate arrays. The polyline is closed if coordinates of the first |
| * point are the same as coordinates of the last point. |
| * |
| * @param xpoints |
| * the array of X point coordinates. |
| * @param ypoints |
| * the array of Y point coordinates. |
| * @param npoints |
| * the number of points. |
| */ |
| public abstract void drawPolyline(int[] xpoints, int[] ypoints, int npoints); |
| |
| /** |
| * Draws the outline of a rectangle with round corners. |
| * |
| * @param x |
| * the X coordinate of the rectangle's top left corner. |
| * @param y |
| * the Y coordinate of the rectangle's top left corner. |
| * @param width |
| * the width of the rectangle. |
| * @param height |
| * the height of the rectangle. |
| * @param arcWidth |
| * the arc width for the corners. |
| * @param arcHeight |
| * the arc height for the corners. |
| */ |
| public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, |
| int arcHeight); |
| |
| /** |
| * Draws a text defined by an iterator. The iterator should specify the font |
| * for every character. |
| * |
| * @param iterator |
| * the iterator. |
| * @param x |
| * the X coordinate of the first character. |
| * @param y |
| * the Y coordinate of the first character. |
| */ |
| public abstract void drawString(AttributedCharacterIterator iterator, int x, int y); |
| |
| /** |
| * Draws a text defined by a string. This method draws the text with current |
| * font and color. |
| * |
| * @param str |
| * the string. |
| * @param x |
| * the X coordinate of the first character. |
| * @param y |
| * the Y coordinate of the first character. |
| */ |
| public abstract void drawString(String str, int x, int y); |
| |
| /** |
| * Fills the arc covering the rectangle and using the current color. The |
| * rectangle is defined by the origin point (X, Y) and dimensions (width and |
| * height). The arc center is the the center of specified rectangle. The |
| * angle origin is at the 3 o'clock position, and a positive angle gives |
| * counter-clockwise rotation, a negative angle gives clockwise rotation. |
| * |
| * @param x |
| * the X origin coordinate of the rectangle which scales the arc. |
| * @param y |
| * the Y origin coordinate of the rectangle which scales the arc. |
| * @param width |
| * the width of the rectangle which scales the arc. |
| * @param height |
| * the height of the rectangle which scales the arc. |
| * @param sa |
| * start angle - the origin angle of arc. |
| * @param ea |
| * arc angle - the angular arc value relative to the start angle. |
| */ |
| public abstract void fillArc(int x, int y, int width, int height, int sa, int ea); |
| |
| /** |
| * Fills an oval with the current color where the oval is defined by the |
| * bounding rectangle with the given width, height, and top left corner. |
| * |
| * @param x |
| * the X top left corner oval coordinate. |
| * @param y |
| * the Y top left corner oval coordinate. |
| * @param width |
| * the oval width. |
| * @param height |
| * the oval height. |
| */ |
| public abstract void fillOval(int x, int y, int width, int height); |
| |
| /** |
| * Fills a polygon with the current color. The polygon vertices are defined |
| * by the points with xpoints[i], ypoints[i] as coordinates. The polygon |
| * edges are the lines from the points with (xpoints[i-1], ypoints[i-1]) |
| * coordinates to the points with (xpoints[i], ypoints[i]) coordinates, for |
| * 0 < i < npoints +1. |
| * |
| * @param xpoints |
| * the array of X coordinates of the polygon vertices. |
| * @param ypoints |
| * the array of Y coordinates of the polygon vertices. |
| * @param npoints |
| * the number of polygon vertices/points. |
| */ |
| public abstract void fillPolygon(int[] xpoints, int[] ypoints, int npoints); |
| |
| /** |
| * Fills a rectangle with the current color. The rectangle is defined by its |
| * width and length and top left corner coordinates. |
| * |
| * @param x |
| * the X coordinate of the rectangle's top left corner. |
| * @param y |
| * the Y coordinate of the rectangle's top left corner. |
| * @param width |
| * the width of rectangle. |
| * @param height |
| * the height of rectangle. |
| */ |
| public abstract void fillRect(int x, int y, int width, int height); |
| |
| /** |
| * Fills a round cornered rectangle with the current color. |
| * |
| * @param x |
| * the X coordinate of the top left corner of the bounding |
| * rectangle. |
| * @param y |
| * the Y coordinate of the top left corner of the bounding |
| * rectangle. |
| * @param width |
| * the width of the bounding rectangle. |
| * @param height |
| * the height of the bounding rectangle. |
| * @param arcWidth |
| * the arc width at the corners. |
| * @param arcHeight |
| * the arc height at the corners. |
| */ |
| public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, |
| int arcHeight); |
| |
| /** |
| * Gets the clipping area. <br> |
| * <br> |
| * |
| * @return a Shape object of the clipping area or null if it is not set. |
| */ |
| public abstract Shape getClip(); |
| |
| /** |
| * Gets the bounds of the current clipping area as a rectangle. |
| * |
| * @return a Rectangle object which represents the bounds of the current |
| * clipping area. |
| */ |
| public abstract Rectangle getClipBounds(); |
| |
| /** |
| * Gets the current color of Graphics. |
| * |
| * @return the current color. |
| */ |
| public abstract Color getColor(); |
| |
| /** |
| * Gets the current font of Graphics. |
| * |
| * @return the current font. |
| */ |
| public abstract Font getFont(); |
| |
| /** |
| * Gets the font metrics of the specified font. The font metrics object |
| * contains information about the rendering of a particular font. |
| * |
| * @param font |
| * the specified font. |
| * @return the font metrics for the specified font. |
| */ |
| public abstract FontMetrics getFontMetrics(Font font); |
| |
| /** |
| * Sets the new clipping area specified by rectangle. The new clipping area |
| * doesn't depend on the window's visibility. Rendering operations can't be |
| * performed outside new clipping area. |
| * |
| * @param x |
| * the X coordinate of the new clipping rectangle. |
| * @param y |
| * the Y coordinate of the new clipping rectangle. |
| * @param width |
| * the width of the new clipping rectangle. |
| * @param height |
| * the height of the new clipping rectangle. |
| */ |
| public abstract void setClip(int x, int y, int width, int height); |
| |
| /** |
| * Sets the new clipping area to be the area specified by Shape object. The |
| * new clipping area doesn't depend on the window's visibility. Rendering |
| * operations can't be performed outside new clipping area. |
| * |
| * @param clip |
| * the Shape object which represents new clipping area. |
| */ |
| public abstract void setClip(Shape clip); |
| |
| /** |
| * Sets the current Graphics color. All rendering operations with this |
| * Graphics will use this color. |
| * |
| * @param c |
| * the new color. |
| */ |
| public abstract void setColor(Color c); |
| |
| /** |
| * Sets the current Graphics font. All rendering operations with this |
| * Graphics will use this font. |
| * |
| * @param font |
| * the new font. |
| */ |
| public abstract void setFont(Font font); |
| |
| /** |
| * Sets the paint mode for the Graphics which overwrites all rendering |
| * operations with the current color. |
| */ |
| public abstract void setPaintMode(); |
| |
| /** |
| * Sets the XOR mode for the Graphics which changes a pixel from the current |
| * color to the specified XOR color. <br> |
| * <br> |
| * |
| * @param color |
| * the new XOR mode. |
| */ |
| public abstract void setXORMode(Color color); |
| |
| /** |
| * Translates the origin of Graphics current coordinate system to the point |
| * with X, Y coordinates in the current coordinate system. All rendering |
| * operation in this Graphics will be related to the new origin. |
| * |
| * @param x |
| * the X coordinate of the origin. |
| * @param y |
| * the Y coordinate of the origin. |
| */ |
| public abstract void translate(int x, int y); |
| } |
