/*
* 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);
}
}