513 lines
17 KiB
Java
513 lines
17 KiB
Java
/*
|
|
* 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.
|
|
*/
|
|
|
|
package java.awt;
|
|
|
|
import java.awt.font.GlyphVector;
|
|
import java.awt.font.FontRenderContext;
|
|
import java.awt.geom.AffineTransform;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.BufferedImageOp;
|
|
import java.awt.image.ImageObserver;
|
|
import java.awt.image.RenderedImage;
|
|
import java.awt.image.renderable.RenderableImage;
|
|
import java.text.AttributedCharacterIterator;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* The Graphics2D class extends Graphics class and provides more capabilities
|
|
* for rendering text, images, shapes. This provides methods to perform
|
|
* transformation of coordinate system, color management, and text layout. The
|
|
* following attributes exist for rendering:
|
|
* <ul>
|
|
* <li>Color - current Graphics2D color;</li>
|
|
* <li>Font - current Graphics2D font;</li>
|
|
* <li>Stroke - pen with a width of 1 pixel;</li>
|
|
* <li>Transform - current Graphics2D Transformation;</li>
|
|
* <li>Composite - alpha compositing rules for combining source and destination
|
|
* colors.</li>
|
|
* </ul>
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
public abstract class Graphics2D extends Graphics {
|
|
|
|
/**
|
|
* Instantiates a new Graphics2D object. This constructor should never be
|
|
* called directly.
|
|
*/
|
|
protected Graphics2D() {
|
|
super();
|
|
}
|
|
|
|
/**
|
|
* Adds preferences for the rendering algorithms. The preferences are
|
|
* arbitrary and specified by Map objects. All specified by Map object
|
|
* preferences can be modified.
|
|
*
|
|
* @param hints
|
|
* the rendering hints.
|
|
*/
|
|
public abstract void addRenderingHints(Map<?, ?> hints);
|
|
|
|
/**
|
|
* Intersects the current clipping area with the specified Shape and the
|
|
* result becomes a new clipping area. If current clipping area is not
|
|
* defined, the Shape becomes the new clipping area. No rendering operations
|
|
* are allowed outside the clipping area.
|
|
*
|
|
* @param s
|
|
* the specified Shape object which will be intersected with
|
|
* current clipping area.
|
|
*/
|
|
public abstract void clip(Shape s);
|
|
|
|
/**
|
|
* Draws the outline of the specified Shape.
|
|
*
|
|
* @param s
|
|
* the Shape which outline is drawn.
|
|
*/
|
|
public abstract void draw(Shape s);
|
|
|
|
/**
|
|
* Draws the specified GlyphVector object's text at the point x, y.
|
|
*
|
|
* @param g
|
|
* the GlyphVector object to be drawn.
|
|
* @param x
|
|
* the X position where the GlyphVector's text should be
|
|
* rendered.
|
|
* @param y
|
|
* the Y position where the GlyphVector's text should be
|
|
* rendered.
|
|
*/
|
|
public abstract void drawGlyphVector(GlyphVector g, float x, float y);
|
|
|
|
/**
|
|
* Draws the BufferedImage -- modified according to the operation
|
|
* BufferedImageOp -- at the point x, y.
|
|
*
|
|
* @param img
|
|
* the BufferedImage to be rendered.
|
|
* @param op
|
|
* the filter to be applied to the image before rendering.
|
|
* @param x
|
|
* the X coordinate of the point where the image's upper left
|
|
* corner will be placed.
|
|
* @param y
|
|
* the Y coordinate of the point where the image's upper left
|
|
* corner will be placed.
|
|
*/
|
|
public abstract void drawImage(BufferedImage img, BufferedImageOp op, int x, int y);
|
|
|
|
/**
|
|
* Draws BufferedImage transformed from image space into user space
|
|
* according to the AffineTransform xform and notifies the ImageObserver.
|
|
*
|
|
* @param img
|
|
* the BufferedImage to be rendered.
|
|
* @param xform
|
|
* the affine transformation from the image to the user space.
|
|
* @param obs
|
|
* the ImageObserver to be notified about the image conversion.
|
|
* @return true, if the image is successfully loaded and rendered, or it's
|
|
* null, otherwise false.
|
|
*/
|
|
public abstract boolean drawImage(Image img, AffineTransform xform, ImageObserver obs);
|
|
|
|
/**
|
|
* Draws a RenderableImage which is transformed from image space into user
|
|
* according to the AffineTransform xform.
|
|
*
|
|
* @param img
|
|
* the RenderableImage to be rendered.
|
|
* @param xform
|
|
* the affine transformation from image to user space.
|
|
*/
|
|
public abstract void drawRenderableImage(RenderableImage img, AffineTransform xform);
|
|
|
|
/**
|
|
* Draws a RenderedImage which is transformed from image space into user
|
|
* according to the AffineTransform xform.
|
|
*
|
|
* @param img
|
|
* the RenderedImage to be rendered.
|
|
* @param xform
|
|
* the affine transformation from image to user space.
|
|
*/
|
|
public abstract void drawRenderedImage(RenderedImage img, AffineTransform xform);
|
|
|
|
/**
|
|
* Draws the string specified by the AttributedCharacterIterator. The first
|
|
* character's position is specified by the X, Y parameters.
|
|
*
|
|
* @param iterator
|
|
* whose text is drawn.
|
|
* @param x
|
|
* the X position where the first character is drawn.
|
|
* @param y
|
|
* the Y position where the first character is drawn.
|
|
*/
|
|
public abstract void drawString(AttributedCharacterIterator iterator, float x, float y);
|
|
|
|
/**
|
|
* Draws the string specified by the AttributedCharacterIterator. The first
|
|
* character's position is specified by the X, Y parameters.
|
|
*
|
|
* @param iterator
|
|
* whose text is drawn.
|
|
* @param x
|
|
* the X position where the first character is drawn.
|
|
* @param y
|
|
* the Y position where the first character is drawn.
|
|
* @see java.awt.Graphics#drawString(AttributedCharacterIterator, int, int)
|
|
*/
|
|
@Override
|
|
public abstract void drawString(AttributedCharacterIterator iterator, int x, int y);
|
|
|
|
/**
|
|
* Draws the String whose the first character position is specified by the
|
|
* parameters X, Y.
|
|
*
|
|
* @param s
|
|
* the String to be drawn.
|
|
* @param x
|
|
* the X position of the first character.
|
|
* @param y
|
|
* the Y position of the first character.
|
|
*/
|
|
public abstract void drawString(String s, float x, float y);
|
|
|
|
/**
|
|
* Draws the String whose the first character coordinates are specified by
|
|
* the parameters X, Y.
|
|
*
|
|
* @param str
|
|
* the String to be drawn.
|
|
* @param x
|
|
* the X coordinate of the first character.
|
|
* @param y
|
|
* the Y coordinate of the first character.
|
|
* @see java.awt.Graphics#drawString(String, int, int)
|
|
*/
|
|
@Override
|
|
public abstract void drawString(String str, int x, int y);
|
|
|
|
/**
|
|
* Fills the interior of the specified Shape.
|
|
*
|
|
* @param s
|
|
* the Shape to be filled.
|
|
*/
|
|
public abstract void fill(Shape s);
|
|
|
|
/**
|
|
* Gets the background color.
|
|
*
|
|
* @return the current background color.
|
|
*/
|
|
public abstract Color getBackground();
|
|
|
|
/**
|
|
* Gets the current composite of the Graphics2D.
|
|
*
|
|
* @return the current composite which specifies the compositing style.
|
|
*/
|
|
public abstract Composite getComposite();
|
|
|
|
/**
|
|
* Gets the device configuration.
|
|
*
|
|
* @return the device configuration.
|
|
*/
|
|
public abstract GraphicsConfiguration getDeviceConfiguration();
|
|
|
|
/**
|
|
* Gets the rendering context of the Font.
|
|
*
|
|
* @return the FontRenderContext.
|
|
*/
|
|
public abstract FontRenderContext getFontRenderContext();
|
|
|
|
/**
|
|
* Gets the current Paint of Graphics2D.
|
|
*
|
|
* @return the current Paint of Graphics2D.
|
|
*/
|
|
public abstract Paint getPaint();
|
|
|
|
/**
|
|
* Gets the value of single preference for specified key.
|
|
*
|
|
* @param key
|
|
* the specified key of the rendering hint.
|
|
* @return the value of rendering hint for specified key.
|
|
*/
|
|
public abstract Object getRenderingHint(RenderingHints.Key key);
|
|
|
|
/**
|
|
* Gets the set of the rendering preferences as a collection of key/value
|
|
* pairs.
|
|
*
|
|
* @return the RenderingHints which contains the rendering preferences.
|
|
*/
|
|
public abstract RenderingHints getRenderingHints();
|
|
|
|
/**
|
|
* Gets current stroke of the Graphics2D.
|
|
*
|
|
* @return current stroke of the Graphics2D.
|
|
*/
|
|
public abstract Stroke getStroke();
|
|
|
|
/**
|
|
* Gets current affine transform of the Graphics2D.
|
|
*
|
|
* @return current AffineTransform of the Graphics2D.
|
|
*/
|
|
public abstract AffineTransform getTransform();
|
|
|
|
/**
|
|
* Determines whether or not the specified Shape intersects the specified
|
|
* Rectangle. If the onStroke parameter is true, this method checks whether
|
|
* or not the specified Shape outline intersects the specified Rectangle,
|
|
* otherwise this method checks whether or not the specified Shape's
|
|
* interior intersects the specified Rectangle.
|
|
*
|
|
* @param rect
|
|
* the specified Rectangle.
|
|
* @param s
|
|
* the Shape to check for intersection.
|
|
* @param onStroke
|
|
* the parameter determines whether or not this method checks for
|
|
* intersection of the Shape outline or of the Shape interior
|
|
* with the Rectangle.
|
|
* @return true, if there is a hit, false otherwise.
|
|
*/
|
|
public abstract boolean hit(Rectangle rect, Shape s, boolean onStroke);
|
|
|
|
/**
|
|
* Performs a rotation transform relative to current Graphics2D Transform.
|
|
* The coordinate system is rotated by the specified angle in radians
|
|
* relative to current origin.
|
|
*
|
|
* @param theta
|
|
* the angle of rotation in radians.
|
|
*/
|
|
public abstract void rotate(double theta);
|
|
|
|
/**
|
|
* Performs a translated rotation transform relative to current Graphics2D
|
|
* Transform. The coordinate system is rotated by the specified angle in
|
|
* radians relative to current origin and then moved to point (x, y). Is
|
|
* this right?
|
|
*
|
|
* @param theta
|
|
* the angle of rotation in radians.
|
|
* @param x
|
|
* the X coordinate.
|
|
* @param y
|
|
* the Y coordinate.
|
|
*/
|
|
public abstract void rotate(double theta, double x, double y);
|
|
|
|
/**
|
|
* Performs a linear scale transform relative to current Graphics2D
|
|
* Transform. The coordinate system is rescaled vertically and horizontally
|
|
* by the specified parameters.
|
|
*
|
|
* @param sx
|
|
* the scaling factor by which the X coordinate is multiplied.
|
|
* @param sy
|
|
* the scaling factor by which the Y coordinate is multiplied.
|
|
*/
|
|
public abstract void scale(double sx, double sy);
|
|
|
|
/**
|
|
* Sets a new background color for clearing rectangular areas. The clearRect
|
|
* method uses the current background color.
|
|
*
|
|
* @param color
|
|
* the new background color.
|
|
*/
|
|
public abstract void setBackground(Color color);
|
|
|
|
/**
|
|
* Sets the current composite for Graphics2D.
|
|
*
|
|
* @param comp
|
|
* the Composite object.
|
|
*/
|
|
public abstract void setComposite(Composite comp);
|
|
|
|
/**
|
|
* Sets the paint for Graphics2D.
|
|
*
|
|
* @param paint
|
|
* the Paint object.
|
|
*/
|
|
public abstract void setPaint(Paint paint);
|
|
|
|
/**
|
|
* Sets a key-value pair in the current RenderingHints map.
|
|
*
|
|
* @param key
|
|
* the key of the rendering hint to set.
|
|
* @param value
|
|
* the value to set for the rendering hint.
|
|
*/
|
|
public abstract void setRenderingHint(RenderingHints.Key key, Object value);
|
|
|
|
/**
|
|
* Replaces the current rendering hints with the specified rendering
|
|
* preferences.
|
|
*
|
|
* @param hints
|
|
* the new Map of rendering hints.
|
|
*/
|
|
public abstract void setRenderingHints(Map<?, ?> hints);
|
|
|
|
/**
|
|
* Sets the stroke for the Graphics2D.
|
|
*
|
|
* @param s
|
|
* the Stroke object.
|
|
*/
|
|
public abstract void setStroke(Stroke s);
|
|
|
|
/**
|
|
* Overwrite the current Transform of the Graphics2D. The specified
|
|
* Transform should be received from the getTransform() method and should be
|
|
* used only for restoring the original Graphics2D transform after calling
|
|
* draw or fill methods.
|
|
*
|
|
* @param Tx
|
|
* the specified Transform.
|
|
*/
|
|
public abstract void setTransform(AffineTransform Tx);
|
|
|
|
/**
|
|
* Performs a shear transform relative to current Graphics2D Transform. The
|
|
* coordinate system is shifted by the specified multipliers relative to
|
|
* current position.
|
|
*
|
|
* @param shx
|
|
* the multiplier by which the X coordinates shift position along
|
|
* X axis as a function of Y coordinates.
|
|
* @param shy
|
|
* the multiplier by which the Y coordinates shift position along
|
|
* Y axis as a function of X coordinates.
|
|
*/
|
|
public abstract void shear(double shx, double shy);
|
|
|
|
/**
|
|
* Concatenates the AffineTransform object with current Transform of this
|
|
* Graphics2D. The transforms are applied in reverse order with the last
|
|
* specified transform applied first and the next transformation applied to
|
|
* the result of previous transformation. More precisely, if Cx is the
|
|
* current Graphics2D transform, the transform method's result with Tx as
|
|
* the parameter is the transformation Rx, where Rx(p) = Cx(Tx(p)), for p -
|
|
* a point in current coordinate system. Rx becomes the current Transform
|
|
* for this Graphics2D.
|
|
*
|
|
* @param Tx
|
|
* the AffineTransform object to be concatenated with current
|
|
* Transform.
|
|
*/
|
|
public abstract void transform(AffineTransform Tx);
|
|
|
|
/**
|
|
* Performs a translate transform relative to current Graphics2D Transform.
|
|
* The coordinate system is moved by the specified distance relative to
|
|
* current position.
|
|
*
|
|
* @param tx
|
|
* the translation distance along the X axis.
|
|
* @param ty
|
|
* the translation distance along the Y axis.
|
|
*/
|
|
public abstract void translate(double tx, double ty);
|
|
|
|
/**
|
|
* Moves the origin Graphics2D Transform to the point with x, y coordinates
|
|
* in current coordinate system. The new origin of coordinate system is
|
|
* moved to the (x, y) point accordingly. All rendering and transform
|
|
* operations are performed relative to this new origin.
|
|
*
|
|
* @param x
|
|
* the X coordinate.
|
|
* @param y
|
|
* the Y coordinate.
|
|
* @see java.awt.Graphics#translate(int, int)
|
|
*/
|
|
@Override
|
|
public abstract void translate(int x, int y);
|
|
|
|
/**
|
|
* Fills a 3D rectangle with the current color. The rectangle is specified
|
|
* by its width, height, 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.
|
|
* @param raised
|
|
* a boolean value that determines whether the rectangle is drawn
|
|
* as raised or indented.
|
|
* @see java.awt.Graphics#fill3DRect(int, int, int, int, boolean)
|
|
*/
|
|
@Override
|
|
public void fill3DRect(int x, int y, int width, int height, boolean raised) {
|
|
// According to the spec, color should be used instead of paint,
|
|
// so Graphics.fill3DRect resets paint and
|
|
// it should be restored after the call
|
|
Paint savedPaint = getPaint();
|
|
super.fill3DRect(x, y, width, height, raised);
|
|
setPaint(savedPaint);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @see java.awt.Graphics#draw3DRect(int, int, int, int, boolean)
|
|
*/
|
|
@Override
|
|
public void draw3DRect(int x, int y, int width, int height, boolean raised) {
|
|
// According to the spec, color should be used instead of paint,
|
|
// so Graphics.draw3DRect resets paint and
|
|
// it should be restored after the call
|
|
Paint savedPaint = getPaint();
|
|
super.draw3DRect(x, y, width, height, raised);
|
|
setPaint(savedPaint);
|
|
}
|
|
} |