* The backend must at the very least provide a Raster which the the rendering * pipeline can paint into. This must be implemented in * {@link #getDestinationRaster()}. For some backends that might be enough, like * when the target surface can be directly access via the raster (like in * BufferedImages). Other targets need some way to synchronize the raster with * the surface, which can be achieved by implementing the * {@link #updateRaster(Raster, int, int, int, int)} method, which always gets * called after a chunk of data got painted into the raster. *
*Alternativly the backend can provide a method for filling Shapes by * overriding the protected method fillShape(). This can be accomplished * by a polygon filling function of the backend. Keep in mind though that * Shapes can be quite complex (i.e. non-convex and containing holes, etc) * which is not supported by all polygon fillers. Also it must be noted * that fillShape() is expected to handle painting and compositing as well as * clipping and transformation. If your backend can't support this natively, * then you can fallback to the implementation in this class. You'll need * to provide a writable Raster then, see above.
*Another alternative is to implement fillScanline() which only requires * the backend to be able to draw horizontal lines in device space, * which is usually very cheap. * The implementation should still handle painting and compositing, * but no more clipping and transformation is required by the backend.
*The backend is free to provide implementations for the various raw* * methods for optimized AWT 1.1 style painting of some primitives. This should * accelerate painting of Swing greatly. When doing so, the backend must also * keep track of the clip and translation, probably by overriding * some clip and translate methods. Don't forget to message super in such a * case.
* ** The fact that it is * pure Java makes it a little slow. However, there are several ways of * accelerating the rendering pipeline: *
raw* method, which get called when
* several optimization conditions are fullfilled. These conditions are
* described below. Subclasses can override these methods and delegate
* it directly to a native backend.areaOfInterest.
*
* This method is implemented to special case RenderableImages and
* RenderedImages and delegate to
* {@link #drawRenderableImage(RenderableImage, AffineTransform)} and
* {@link #drawRenderedImage(RenderedImage, AffineTransform)} accordingly.
* Other image types are not yet handled.
*
* @param image the image to be rendered
* @param xform the transform from image space to user space
* @param obs the image observer to be notified
* @param areaOfInterest the area in image space that is rendered
*/
private boolean drawImageImpl(Image image, AffineTransform xform,
ImageObserver obs, Rectangle areaOfInterest)
{
boolean ret;
if (image == null)
{
ret = true;
}
else if (image instanceof RenderedImage)
{
// FIXME: Handle the ImageObserver.
drawRenderedImageImpl((RenderedImage) image, xform, areaOfInterest);
ret = true;
}
else if (image instanceof RenderableImage)
{
// FIXME: Handle the ImageObserver.
drawRenderableImageImpl((RenderableImage) image, xform, areaOfInterest);
ret = true;
}
else
{
// FIXME: Implement rendering of other Image types.
ret = false;
}
return ret;
}
/**
* Renders a BufferedImage and applies the specified BufferedImageOp before
* to filter the BufferedImage somehow. The resulting BufferedImage is then
* passed on to {@link #drawRenderedImage(RenderedImage, AffineTransform)}
* to perform the final rendering.
*
* @param image the source buffered image
* @param op the filter to apply to the buffered image before rendering
* @param x the x coordinate to render the image to
* @param y the y coordinate to render the image to
*/
public void drawImage(BufferedImage image, BufferedImageOp op, int x, int y)
{
BufferedImage filtered =
op.createCompatibleDestImage(image, image.getColorModel());
AffineTransform t = new AffineTransform();
t.translate(x, y);
drawRenderedImage(filtered, t);
}
/**
* Renders the specified image to the destination raster. The specified
* transform is used to convert the image into user space. The transform
* of this AbstractGraphics2D object is used to transform from user space
* to device space.
*
* The rendering is performed using the scanline algorithm that performs the
* rendering of other shapes and a custom Paint implementation, that supplies
* the pixel values of the rendered image.
*
* @param image the image to render to the destination raster
* @param xform the transform from image space to user space
*/
public void drawRenderedImage(RenderedImage image, AffineTransform xform)
{
Rectangle areaOfInterest = new Rectangle(image.getMinX(),
image.getHeight(),
image.getWidth(),
image.getHeight());
drawRenderedImageImpl(image, xform, areaOfInterest);
}
/**
* Renders the specified image to the destination raster. The specified
* transform is used to convert the image into user space. The transform
* of this AbstractGraphics2D object is used to transform from user space
* to device space. Only the area specified by areaOfInterest
* is finally rendered to the target.
*
* The rendering is performed using the scanline algorithm that performs the
* rendering of other shapes and a custom Paint implementation, that supplies
* the pixel values of the rendered image.
*
* @param image the image to render to the destination raster
* @param xform the transform from image space to user space
*/
private void drawRenderedImageImpl(RenderedImage image,
AffineTransform xform,
Rectangle areaOfInterest)
{
// First we compute the transformation. This is made up of 3 parts:
// 1. The areaOfInterest -> image space transform.
// 2. The image space -> user space transform.
// 3. The user space -> device space transform.
AffineTransform t = new AffineTransform();
t.translate(- areaOfInterest.x - image.getMinX(),
- areaOfInterest.y - image.getMinY());
t.concatenate(xform);
t.concatenate(transform);
AffineTransform it = null;
try
{
it = t.createInverse();
}
catch (NoninvertibleTransformException ex)
{
// Ignore -- we return if the transform is not invertible.
}
if (it != null)
{
// Transform the area of interest into user space.
GeneralPath aoi = new GeneralPath(areaOfInterest);
aoi.transform(xform);
// Render the shape using the standard renderer, but with a temporary
// ImagePaint.
ImagePaint p = new ImagePaint(image, it);
Paint savedPaint = paint;
try
{
paint = p;
fillShape(aoi, false);
}
finally
{
paint = savedPaint;
}
}
}
/**
* Renders a renderable image. This produces a RenderedImage, which is
* then passed to {@link #drawRenderedImage(RenderedImage, AffineTransform)}
* to perform the final rendering.
*
* @param image the renderable image to be rendered
* @param xform the transform from image space to user space
*/
public void drawRenderableImage(RenderableImage image, AffineTransform xform)
{
Rectangle areaOfInterest = new Rectangle((int) image.getMinX(),
(int) image.getHeight(),
(int) image.getWidth(),
(int) image.getHeight());
drawRenderableImageImpl(image, xform, areaOfInterest);
}
/**
* Renders a renderable image. This produces a RenderedImage, which is
* then passed to {@link #drawRenderedImage(RenderedImage, AffineTransform)}
* to perform the final rendering. Only the area of the image specified
* by areaOfInterest is rendered.
*
* @param image the renderable image to be rendered
* @param xform the transform from image space to user space
*/
private void drawRenderableImageImpl(RenderableImage image,
AffineTransform xform,
Rectangle areaOfInterest)
{
// TODO: Maybe make more clever usage of a RenderContext here.
RenderedImage rendered = image.createDefaultRendering();
drawRenderedImageImpl(rendered, xform, areaOfInterest);
}
/**
* Draws the specified string at the specified location.
*
* @param text the string to draw
* @param x the x location, relative to the bounding rectangle of the text
* @param y the y location, relative to the bounding rectangle of the text
*/
public void drawString(String text, int x, int y)
{
GlyphVector gv;
synchronized (searchTextKey)
{
TextCacheKey tck = searchTextKey;
FontRenderContext frc = getFontRenderContext();
tck.setString(text);
tck.setFont(font);
tck.setFontRenderContext(frc);
if (gvCache.containsKey(tck))
{
gv = gvCache.get(tck);
}
else
{
gv = font.createGlyphVector(frc, text.toCharArray());
gvCache.put(new TextCacheKey(text, font, frc), gv);
}
}
drawGlyphVector(gv, x, y);
}
/**
* Draws the specified string at the specified location.
*
* @param text the string to draw
* @param x the x location, relative to the bounding rectangle of the text
* @param y the y location, relative to the bounding rectangle of the text
*/
public void drawString(String text, float x, float y)
{
FontRenderContext ctx = getFontRenderContext();
GlyphVector gv = font.createGlyphVector(ctx, text.toCharArray());
drawGlyphVector(gv, x, y);
}
/**
* Draws the specified string (as AttributedCharacterIterator) at the
* specified location.
*
* @param iterator the string to draw
* @param x the x location, relative to the bounding rectangle of the text
* @param y the y location, relative to the bounding rectangle of the text
*/
public void drawString(AttributedCharacterIterator iterator, int x, int y)
{
FontRenderContext ctx = getFontRenderContext();
GlyphVector gv = font.createGlyphVector(ctx, iterator);
drawGlyphVector(gv, x, y);
}
/**
* Draws the specified string (as AttributedCharacterIterator) at the
* specified location.
*
* @param iterator the string to draw
* @param x the x location, relative to the bounding rectangle of the text
* @param y the y location, relative to the bounding rectangle of the text
*/
public void drawString(AttributedCharacterIterator iterator, float x, float y)
{
FontRenderContext ctx = getFontRenderContext();
GlyphVector gv = font.createGlyphVector(ctx, iterator);
drawGlyphVector(gv, x, y);
}
/**
* Fills the specified shape with the current foreground.
*
* @param shape the shape to fill
*/
public void fill(Shape shape)
{
fillShape(shape, false);
}
public boolean hit(Rectangle rect, Shape text, boolean onStroke)
{
// FIXME: Implement this.
throw new UnsupportedOperationException("Not yet implemented");
}
/**
* Sets the composite.
*
* @param comp the composite to set
*/
public void setComposite(Composite comp)
{
if (! (comp instanceof AlphaComposite))
{
// FIXME: this check is only required "if this Graphics2D
// context is drawing to a Component on the display screen".
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPermission(new AWTPermission("readDisplayPixels"));
}
composite = comp;
if (! (comp.equals(AlphaComposite.SrcOver)))
isOptimized = false;
else
updateOptimization();
}
/**
* Sets the current foreground.
*
* @param p the foreground to set.
*/
public void setPaint(Paint p)
{
if (p != null)
{
paint = p;
if (! (paint instanceof Color))
{
isOptimized = false;
}
else
{
this.foreground = (Color) paint;
isForegroundColorNull = false;
updateOptimization();
}
}
else
{
this.foreground = Color.BLACK;
isForegroundColorNull = true;
}
// free resources if needed, then put the paint context to null
if (this.paintContext != null)
this.paintContext.dispose();
this.paintContext = null;
}
/**
* Sets the stroke for this graphics object.
*
* @param s the stroke to set
*/
public void setStroke(Stroke s)
{
stroke = s;
if (! stroke.equals(new BasicStroke()))
isOptimized = false;
else
updateOptimization();
}
/**
* Sets the specified rendering hint.
*
* @param hintKey the key of the rendering hint
* @param hintValue the value
*/
public void setRenderingHint(Key hintKey, Object hintValue)
{
renderingHints.put(hintKey, hintValue);
}
/**
* Returns the rendering hint for the specified key.
*
* @param hintKey the rendering hint key
*
* @return the rendering hint for the specified key
*/
public Object getRenderingHint(Key hintKey)
{
return renderingHints.get(hintKey);
}
/**
* Sets the specified rendering hints.
*
* @param hints the rendering hints to set
*/
public void setRenderingHints(Map hints)
{
renderingHints.clear();
renderingHints.putAll(hints);
}
/**
* Adds the specified rendering hints.
*
* @param hints the rendering hints to add
*/
public void addRenderingHints(Map hints)
{
renderingHints.putAll(hints);
}
/**
* Returns the current rendering hints.
*
* @return the current rendering hints
*/
public RenderingHints getRenderingHints()
{
return (RenderingHints) renderingHints.clone();
}
/**
* Translates the coordinate system by (x, y).
*
* @param x the translation X coordinate
* @param y the translation Y coordinate
*/
public void translate(int x, int y)
{
transform.translate(x, y);
// Update the clip. We special-case rectangular clips here, because they
// are so common (e.g. in Swing).
if (clip != null)
{
if (clip instanceof Rectangle)
{
Rectangle r = (Rectangle) clip;
r.x -= x;
r.y -= y;
setClip(r);
}
else
{
AffineTransform clipTransform = new AffineTransform();
clipTransform.translate(-x, -y);
updateClip(clipTransform);
}
}
}
/**
* Translates the coordinate system by (tx, ty).
*
* @param tx the translation X coordinate
* @param ty the translation Y coordinate
*/
public void translate(double tx, double ty)
{
transform.translate(tx, ty);
// Update the clip. We special-case rectangular clips here, because they
// are so common (e.g. in Swing).
if (clip != null)
{
if (clip instanceof Rectangle)
{
Rectangle r = (Rectangle) clip;
r.x -= tx;
r.y -= ty;
}
else
{
AffineTransform clipTransform = new AffineTransform();
clipTransform.translate(-tx, -ty);
updateClip(clipTransform);
}
}
}
/**
* Rotates the coordinate system by theta degrees.
*
* @param theta the angle be which to rotate the coordinate system
*/
public void rotate(double theta)
{
transform.rotate(theta);
if (clip != null)
{
AffineTransform clipTransform = new AffineTransform();
clipTransform.rotate(-theta);
updateClip(clipTransform);
}
updateOptimization();
}
/**
* Rotates the coordinate system by theta around the point
* (x, y).
*
* @param theta the angle by which to rotate the coordinate system
* @param x the point around which to rotate, X coordinate
* @param y the point around which to rotate, Y coordinate
*/
public void rotate(double theta, double x, double y)
{
transform.rotate(theta, x, y);
if (clip != null)
{
AffineTransform clipTransform = new AffineTransform();
clipTransform.rotate(-theta, x, y);
updateClip(clipTransform);
}
updateOptimization();
}
/**
* Scales the coordinate system by the factors scaleX and
* scaleY.
*
* @param scaleX the factor by which to scale the X axis
* @param scaleY the factor by which to scale the Y axis
*/
public void scale(double scaleX, double scaleY)
{
transform.scale(scaleX, scaleY);
if (clip != null)
{
AffineTransform clipTransform = new AffineTransform();
clipTransform.scale(1 / scaleX, 1 / scaleY);
updateClip(clipTransform);
}
updateOptimization();
}
/**
* Shears the coordinate system by shearX and
* shearY.
*
* @param shearX the X shearing
* @param shearY the Y shearing
*/
public void shear(double shearX, double shearY)
{
transform.shear(shearX, shearY);
if (clip != null)
{
AffineTransform clipTransform = new AffineTransform();
clipTransform.shear(-shearX, -shearY);
updateClip(clipTransform);
}
updateOptimization();
}
/**
* Transforms the coordinate system using the specified transform
* t.
*
* @param t the transform
*/
public void transform(AffineTransform t)
{
transform.concatenate(t);
try
{
AffineTransform clipTransform = t.createInverse();
updateClip(clipTransform);
}
catch (NoninvertibleTransformException ex)
{
// TODO: How can we deal properly with this?
ex.printStackTrace();
}
updateOptimization();
}
/**
* Sets the transformation for this Graphics object.
*
* @param t the transformation to set
*/
public void setTransform(AffineTransform t)
{
// Transform clip into target space using the old transform.
updateClip(transform);
transform.setTransform(t);
// Transform the clip back into user space using the inverse new transform.
try
{
updateClip(transform.createInverse());
}
catch (NoninvertibleTransformException ex)
{
// TODO: How can we deal properly with this?
ex.printStackTrace();
}
updateOptimization();
}
/**
* Returns the transformation of this coordinate system.
*
* @return the transformation of this coordinate system
*/
public AffineTransform getTransform()
{
return (AffineTransform) transform.clone();
}
/**
* Returns the current foreground.
*
* @return the current foreground
*/
public Paint getPaint()
{
return paint;
}
/**
* Returns the current composite.
*
* @return the current composite
*/
public Composite getComposite()
{
return composite;
}
/**
* Sets the current background.
*
* @param color the background to set.
*/
public void setBackground(Color color)
{
background = color;
}
/**
* Returns the current background.
*
* @return the current background
*/
public Color getBackground()
{
return background;
}
/**
* Returns the current stroke.
*
* @return the current stroke
*/
public Stroke getStroke()
{
return stroke;
}
/**
* Intersects the clip of this graphics object with the specified clip.
*
* @param s the clip with which the current clip should be intersected
*/
public void clip(Shape s)
{
// Initialize clip if not already present.
if (clip == null)
setClip(s);
// This is so common, let's optimize this.
else if (clip instanceof Rectangle && s instanceof Rectangle)
{
Rectangle clipRect = (Rectangle) clip;
Rectangle r = (Rectangle) s;
computeIntersection(r.x, r.y, r.width, r.height, clipRect);
// Call setClip so that subclasses get notified.
setClip(clipRect);
}
else
{
Area current;
if (clip instanceof Area)
current = (Area) clip;
else
current = new Area(clip);
Area intersect;
if (s instanceof Area)
intersect = (Area) s;
else
intersect = new Area(s);
current.intersect(intersect);
clip = current;
isOptimized = false;
// Call setClip so that subclasses get notified.
setClip(clip);
}
}
public FontRenderContext getFontRenderContext()
{
// Protect our own transform from beeing modified.
AffineTransform tf = new AffineTransform(transform);
// TODO: Determine antialias and fractionalmetrics parameters correctly.
return new FontRenderContext(tf, false, true);
}
/**
* Draws the specified glyph vector at the specified location.
*
* @param gv the glyph vector to draw
* @param x the location, x coordinate
* @param y the location, y coordinate
*/
public void drawGlyphVector(GlyphVector gv, float x, float y)
{
translate(x, y);
fillShape(gv.getOutline(), true);
translate(-x, -y);
}
/**
* Creates a copy of this graphics object.
*
* @return a copy of this graphics object
*/
public Graphics create()
{
AbstractGraphics2D copy = (AbstractGraphics2D) clone();
return copy;
}
/**
* Creates and returns a copy of this Graphics object. This should
* be overridden by subclasses if additional state must be handled when
* cloning. This is called by {@link #create()}.
*
* @return a copy of this Graphics object
*/
protected Object clone()
{
try
{
AbstractGraphics2D copy = (AbstractGraphics2D) super.clone();
// Copy the clip. If it's a Rectangle, preserve that for optimization.
if (clip instanceof Rectangle)
copy.clip = new Rectangle((Rectangle) clip);
else if (clip != null)
copy.clip = new GeneralPath(clip);
else
copy.clip = null;
copy.renderingHints = new RenderingHints(null);
copy.renderingHints.putAll(renderingHints);
copy.transform = new AffineTransform(transform);
// The remaining state is inmmutable and doesn't need to be copied.
return copy;
}
catch (CloneNotSupportedException ex)
{
AWTError err = new AWTError("Unexpected exception while cloning");
err.initCause(ex);
throw err;
}
}
/**
* Returns the current foreground.
*/
public Color getColor()
{
if (isForegroundColorNull)
return null;
return this.foreground;
}
/**
* Sets the current foreground.
*
* @param color the foreground to set
*/
public void setColor(Color color)
{
this.setPaint(color);
}
public void setPaintMode()
{
// FIXME: Implement this.
throw new UnsupportedOperationException("Not yet implemented");
}
public void setXORMode(Color color)
{
// FIXME: Implement this.
throw new UnsupportedOperationException("Not yet implemented");
}
/**
* Returns the current font.
*
* @return the current font
*/
public Font getFont()
{
return font;
}
/**
* Sets the font on this graphics object. When f == null, the
* current setting is not changed.
*
* @param f the font to set
*/
public void setFont(Font f)
{
if (f != null)
font = f;
}
/**
* Returns the font metrics for the specified font.
*
* @param font the font for which to fetch the font metrics
*
* @return the font metrics for the specified font
*/
public FontMetrics getFontMetrics(Font font)
{
return Toolkit.getDefaultToolkit().getFontMetrics(font);
}
/**
* Returns the bounds of the current clip.
*
* @return the bounds of the current clip
*/
public Rectangle getClipBounds()
{
Rectangle b = null;
if (clip != null)
b = clip.getBounds();
return b;
}
/**
* Intersects the current clipping region with the specified rectangle.
*
* @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 void clipRect(int x, int y, int width, int height)
{
clip(new Rectangle(x, y, width, height));
}
/**
* Sets the clip to the specified rectangle.
*
* @param x the x coordinate of the clip rectangle
* @param y the y coordinate of the clip rectangle
* @param width the width of the clip rectangle
* @param height the height of the clip rectangle
*/
public void setClip(int x, int y, int width, int height)
{
setClip(new Rectangle(x, y, width, height));
}
/**
* Returns the current clip.
*
* @return the current clip
*/
public Shape getClip()
{
return clip;
}
/**
* Sets the current clipping area to clip.
*
* @param c the clip to set
*/
public void setClip(Shape c)
{
clip = c;
if (! (clip instanceof Rectangle))
isOptimized = false;
else
updateOptimization();
}
public void copyArea(int x, int y, int width, int height, int dx, int dy)
{
if (isOptimized)
rawCopyArea(x, y, width, height, dx, dy);
else
copyAreaImpl(x, y, width, height, dx, dy);
}
/**
* Draws a line from (x1, y1) to (x2, y2).
*
* This implementation transforms the coordinates and forwards the call to
* {@link #rawDrawLine}.
*/
public void drawLine(int x1, int y1, int x2, int y2)
{
if (isOptimized)
{
int tx = (int) transform.getTranslateX();
int ty = (int) transform.getTranslateY();
rawDrawLine(x1 + tx, y1 + ty, x2 + tx, y2 + ty);
}
else
{
ShapeCache sc = shapeCache;
if (sc.line == null)
sc.line = new Line2D.Float();
sc.line.setLine(x1, y1, x2, y2);
draw(sc.line);
}
}
public void drawRect(int x, int y, int w, int h)
{
if (isOptimized)
{
int tx = (int) transform.getTranslateX();
int ty = (int) transform.getTranslateY();
rawDrawRect(x + tx, y + ty, w, h);
}
else
{
ShapeCache sc = shapeCache;
if (sc.rect == null)
sc.rect = new Rectangle();
sc.rect.setBounds(x, y, w, h);
draw(sc.rect);
}
}
/**
* Fills a rectangle with the current paint.
*
* @param x the upper left corner, X coordinate
* @param y the upper left corner, Y coordinate
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
public void fillRect(int x, int y, int width, int height)
{
if (isOptimized)
{
rawFillRect(x + (int) transform.getTranslateX(),
y + (int) transform.getTranslateY(), width, height);
}
else
{
ShapeCache sc = shapeCache;
if (sc.rect == null)
sc.rect = new Rectangle();
sc.rect.setBounds(x, y, width, height);
fill(sc.rect);
}
}
/**
* Fills a rectangle with the current background color.
*
* This implementation temporarily sets the foreground color to the
* background and forwards the call to {@link #fillRect(int, int, int, int)}.
*
* @param x the upper left corner, X coordinate
* @param y the upper left corner, Y coordinate
* @param width the width of the rectangle
* @param height the height of the rectangle
*/
public void clearRect(int x, int y, int width, int height)
{
if (isOptimized)
rawClearRect(x, y, width, height);
else
{
Paint savedForeground = getPaint();
setPaint(getBackground());
fillRect(x, y, width, height);
setPaint(savedForeground);
}
}
/**
* Draws a rounded rectangle.
*
* @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
* @param arcWidth the width of the arcs
* @param arcHeight the height of the arcs
*/
public void drawRoundRect(int x, int y, int width, int height, int arcWidth,
int arcHeight)
{
ShapeCache sc = shapeCache;
if (sc.roundRect == null)
sc.roundRect = new RoundRectangle2D.Float();
sc.roundRect.setRoundRect(x, y, width, height, arcWidth, arcHeight);
draw(sc.roundRect);
}
/**
* Fills a rounded rectangle.
*
* @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
* @param arcWidth the width of the arcs
* @param arcHeight the height of the arcs
*/
public void fillRoundRect(int x, int y, int width, int height, int arcWidth,
int arcHeight)
{
ShapeCache sc = shapeCache;
if (sc.roundRect == null)
sc.roundRect = new RoundRectangle2D.Float();
sc.roundRect.setRoundRect(x, y, width, height, arcWidth, arcHeight);
fill(sc.roundRect);
}
/**
* Draws the outline of an oval.
*
* @param x the upper left corner of the bounding rectangle of the ellipse
* @param y the upper left corner of the bounding rectangle of the ellipse
* @param width the width of the ellipse
* @param height the height of the ellipse
*/
public void drawOval(int x, int y, int width, int height)
{
ShapeCache sc = shapeCache;
if (sc.ellipse == null)
sc.ellipse = new Ellipse2D.Float();
sc.ellipse.setFrame(x, y, width, height);
draw(sc.ellipse);
}
/**
* Fills an oval.
*
* @param x the upper left corner of the bounding rectangle of the ellipse
* @param y the upper left corner of the bounding rectangle of the ellipse
* @param width the width of the ellipse
* @param height the height of the ellipse
*/
public void fillOval(int x, int y, int width, int height)
{
ShapeCache sc = shapeCache;
if (sc.ellipse == null)
sc.ellipse = new Ellipse2D.Float();
sc.ellipse.setFrame(x, y, width, height);
fill(sc.ellipse);
}
/**
* Draws an arc.
*/
public void drawArc(int x, int y, int width, int height, int arcStart,
int arcAngle)
{
ShapeCache sc = shapeCache;
if (sc.arc == null)
sc.arc = new Arc2D.Float();
sc.arc.setArc(x, y, width, height, arcStart, arcAngle, Arc2D.OPEN);
draw(sc.arc);
}
/**
* Fills an arc.
*/
public void fillArc(int x, int y, int width, int height, int arcStart,
int arcAngle)
{
ShapeCache sc = shapeCache;
if (sc.arc == null)
sc.arc = new Arc2D.Float();
sc.arc.setArc(x, y, width, height, arcStart, arcAngle, Arc2D.PIE);
draw(sc.arc);
}
public void drawPolyline(int[] xPoints, int[] yPoints, int npoints)
{
ShapeCache sc = shapeCache;
if (sc.polyline == null)
sc.polyline = new GeneralPath();
GeneralPath p = sc.polyline;
p.reset();
if (npoints > 0)
p.moveTo(xPoints[0], yPoints[0]);
for (int i = 1; i < npoints; i++)
p.lineTo(xPoints[i], yPoints[i]);
fill(p);
}
/**
* Draws the outline of a polygon.
*/
public void drawPolygon(int[] xPoints, int[] yPoints, int npoints)
{
ShapeCache sc = shapeCache;
if (sc.polygon == null)
sc.polygon = new Polygon();
sc.polygon.reset();
sc.polygon.xpoints = xPoints;
sc.polygon.ypoints = yPoints;
sc.polygon.npoints = npoints;
draw(sc.polygon);
}
/**
* Fills the outline of a polygon.
*/
public void fillPolygon(int[] xPoints, int[] yPoints, int npoints)
{
ShapeCache sc = shapeCache;
if (sc.polygon == null)
sc.polygon = new Polygon();
sc.polygon.reset();
sc.polygon.xpoints = xPoints;
sc.polygon.ypoints = yPoints;
sc.polygon.npoints = npoints;
fill(sc.polygon);
}
/**
* Draws the specified image at the specified location. This forwards
* to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
*
* @param image the image to render
* @param x the x location to render to
* @param y the y location to render to
* @param observer the image observer to receive notification
*/
public boolean drawImage(Image image, int x, int y, ImageObserver observer)
{
boolean ret;
if (isOptimized)
{
ret = rawDrawImage(image, x + (int) transform.getTranslateX(),
y + (int) transform.getTranslateY(), observer);
}
else
{
AffineTransform t = new AffineTransform();
t.translate(x, y);
ret = drawImage(image, t, observer);
}
return ret;
}
/**
* Draws the specified image at the specified location. The image
* is scaled to the specified width and height. This forwards
* to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
*
* @param image the image to render
* @param x the x location to render to
* @param y the y location to render to
* @param width the target width of the image
* @param height the target height of the image
* @param observer the image observer to receive notification
*/
public boolean drawImage(Image image, int x, int y, int width, int height,
ImageObserver observer)
{
AffineTransform t = new AffineTransform();
int imWidth = image.getWidth(observer);
int imHeight = image.getHeight(observer);
if (imWidth == width && imHeight == height)
{
// No need to scale, fall back to non-scaling loops.
return drawImage(image, x, y, observer);
}
else
{
Image scaled = prepareImage(image, width, height);
// Ideally, this should notify the observer about the scaling progress.
return drawImage(scaled, x, y, observer);
}
}
/**
* Draws the specified image at the specified location. This forwards
* to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
*
* @param image the image to render
* @param x the x location to render to
* @param y the y location to render to
* @param bgcolor the background color to use for transparent pixels
* @param observer the image observer to receive notification
*/
public boolean drawImage(Image image, int x, int y, Color bgcolor,
ImageObserver observer)
{
AffineTransform t = new AffineTransform();
t.translate(x, y);
// TODO: Somehow implement the background option.
return drawImage(image, t, observer);
}
/**
* Draws the specified image at the specified location. The image
* is scaled to the specified width and height. This forwards
* to {@link #drawImage(Image, AffineTransform, ImageObserver)}.
*
* @param image the image to render
* @param x the x location to render to
* @param y the y location to render to
* @param width the target width of the image
* @param height the target height of the image
* @param bgcolor the background color to use for transparent pixels
* @param observer the image observer to receive notification
*/
public boolean drawImage(Image image, int x, int y, int width, int height,
Color bgcolor, ImageObserver observer)
{
AffineTransform t = new AffineTransform();
t.translate(x, y);
double scaleX = (double) image.getWidth(observer) / (double) width;
double scaleY = (double) image.getHeight(observer) / (double) height;
t.scale(scaleX, scaleY);
// TODO: Somehow implement the background option.
return drawImage(image, t, observer);
}
/**
* Draws an image fragment to a rectangular area of the target.
*
* @param image the image to render
* @param dx1 the first corner of the destination rectangle
* @param dy1 the first corner of the destination rectangle
* @param dx2 the second corner of the destination rectangle
* @param dy2 the second corner of the destination rectangle
* @param sx1 the first corner of the source rectangle
* @param sy1 the first corner of the source rectangle
* @param sx2 the second corner of the source rectangle
* @param sy2 the second corner of the source rectangle
* @param observer the image observer to be notified
*/
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2,
ImageObserver observer)
{
int sx = Math.min(sx1, sx1);
int sy = Math.min(sy1, sy2);
int sw = Math.abs(sx1 - sx2);
int sh = Math.abs(sy1 - sy2);
int dx = Math.min(dx1, dx1);
int dy = Math.min(dy1, dy2);
int dw = Math.abs(dx1 - dx2);
int dh = Math.abs(dy1 - dy2);
AffineTransform t = new AffineTransform();
t.translate(sx - dx, sy - dy);
double scaleX = (double) sw / (double) dw;
double scaleY = (double) sh / (double) dh;
t.scale(scaleX, scaleY);
Rectangle areaOfInterest = new Rectangle(sx, sy, sw, sh);
return drawImageImpl(image, t, observer, areaOfInterest);
}
/**
* Draws an image fragment to a rectangular area of the target.
*
* @param image the image to render
* @param dx1 the first corner of the destination rectangle
* @param dy1 the first corner of the destination rectangle
* @param dx2 the second corner of the destination rectangle
* @param dy2 the second corner of the destination rectangle
* @param sx1 the first corner of the source rectangle
* @param sy1 the first corner of the source rectangle
* @param sx2 the second corner of the source rectangle
* @param sy2 the second corner of the source rectangle
* @param bgcolor the background color to use for transparent pixels
* @param observer the image observer to be notified
*/
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2, Color bgcolor,
ImageObserver observer)
{
// FIXME: Do something with bgcolor.
return drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observer);
}
/**
* Disposes this graphics object.
*/
public void dispose()
{
// Nothing special to do here.
}
/**
* Fills the specified shape. Override this if your backend can efficiently
* fill shapes. This is possible on many systems via a polygon fill
* method or something similar. But keep in mind that Shapes can be quite
* complex (non-convex, with holes etc), which is not necessarily supported
* by all polygon fillers. Also note that you must perform clipping
* before filling the shape.
*
* @param s the shape to fill
* @param isFont true if the shape is a font outline
*/
protected void fillShape(Shape s, boolean isFont)
{
// Determine if we need to antialias stuff.
boolean antialias = false;
if (isFont)
{
Object v = renderingHints.get(RenderingHints.KEY_TEXT_ANTIALIASING);
// We default to antialiasing for text rendering.
antialias = v == RenderingHints.VALUE_TEXT_ANTIALIAS_ON
|| (v == RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT
&& DEFAULT_TEXT_AA);
}
else
{
Object v = renderingHints.get(RenderingHints.KEY_ANTIALIASING);
antialias = (v == RenderingHints.VALUE_ANTIALIAS_ON);
}
ScanlineConverter sc = getScanlineConverter();
int resolution = 0;
int yRes = 0;
if (antialias)
{
// Adjust resolution according to rendering hints.
resolution = 2;
yRes = 4;
}
sc.renderShape(this, s, clip, transform, resolution, yRes, renderingHints);
freeScanlineConverter(sc);
}
/**
* Returns the color model of this Graphics object.
*
* @return the color model of this Graphics object
*/
protected abstract ColorModel getColorModel();
/**
* Returns the bounds of the target.
*
* @return the bounds of the target
*/
protected abstract Rectangle getDeviceBounds();
/**
* Draws a line in optimization mode. The implementation should respect the
* clip and translation. It can assume that the clip is a rectangle and that
* the transform is only a translating transform.
*
* @param x0 the starting point, X coordinate
* @param y0 the starting point, Y coordinate
* @param x1 the end point, X coordinate
* @param y1 the end point, Y coordinate
*/
protected void rawDrawLine(int x0, int y0, int x1, int y1)
{
ShapeCache sc = shapeCache;
if (sc.line == null)
sc.line = new Line2D.Float();
sc.line.setLine(x0, y0, x1, y1);
draw(sc.line);
}
protected void rawDrawRect(int x, int y, int w, int h)
{
ShapeCache sc = shapeCache;
if (sc.rect == null)
sc.rect = new Rectangle();
sc.rect.setBounds(x, y, w, h);
draw(sc.rect);
}
/**
* Clears a rectangle in optimization mode. The implementation should respect the
* clip and translation. It can assume that the clip is a rectangle and that
* the transform is only a translating transform.
*
* @param x the upper left corner, X coordinate
* @param y the upper left corner, Y coordinate
* @param w the width
* @param h the height
*/
protected void rawClearRect(int x, int y, int w, int h)
{
Paint savedForeground = getPaint();
setPaint(getBackground());
rawFillRect(x, y, w, h);
setPaint(savedForeground);
}
/**
* Fills a rectangle in optimization mode. The implementation should respect
* the clip but can assume that it is a rectangle.
*
* @param x the upper left corner, X coordinate
* @param y the upper left corner, Y coordinate
* @param w the width
* @param h the height
*/
protected void rawFillRect(int x, int y, int w, int h)
{
ShapeCache sc = shapeCache;
if (sc.rect == null)
sc.rect = new Rectangle();
sc.rect.setBounds(x, y, w, h);
fill(sc.rect);
}
/**
* Draws an image in optimization mode. The implementation should respect
* the clip but can assume that it is a rectangle.
*
* @param image the image to be painted
* @param x the location, X coordinate
* @param y the location, Y coordinate
* @param obs the image observer to be notified
*
* @return true when the image is painted completely,
* false if it is still rendered
*/
protected boolean rawDrawImage(Image image, int x, int y, ImageObserver obs)
{
AffineTransform t = new AffineTransform();
t.translate(x, y);
return drawImage(image, t, obs);
}
/**
* Copies a rectangular region to another location.
*
* @param x the upper left corner, X coordinate
* @param y the upper left corner, Y coordinate
* @param w the width
* @param h the height
* @param dx
* @param dy
*/
protected void rawCopyArea(int x, int y, int w, int h, int dx, int dy)
{
copyAreaImpl(x, y, w, h, dx, dy);
}
// Private implementation methods.
/**
* Copies a rectangular area of the target raster to a different location.
*/
private void copyAreaImpl(int x, int y, int w, int h, int dx, int dy)
{
// FIXME: Implement this properly.
throw new UnsupportedOperationException("Not implemented yet.");
}
/**
* Paints a scanline between x0 and x1. Override this when your backend
* can efficiently draw/fill horizontal lines.
*
* @param x0 the left offset
* @param x1 the right offset
* @param y the scanline
*/
public void renderScanline(int y, ScanlineCoverage c)
{
PaintContext pCtx = getPaintContext();
int x0 = c.getMinX();
int x1 = c.getMaxX();
Raster paintRaster = pCtx.getRaster(x0, y, x1 - x0, 1);
// Do the anti aliasing thing.
float coverageAlpha = 0;
float maxCoverage = c.getMaxCoverage();
ColorModel cm = pCtx.getColorModel();
DataBuffer db = paintRaster.getDataBuffer();
Point loc = new Point(paintRaster.getMinX(), paintRaster.getMinY());
SampleModel sm = paintRaster.getSampleModel();
WritableRaster writeRaster = Raster.createWritableRaster(sm, db, loc);
WritableRaster alphaRaster = cm.getAlphaRaster(writeRaster);
int pixel;
ScanlineCoverage.Iterator iter = c.iterate();
while (iter.hasNext())
{
ScanlineCoverage.Range range = iter.next();
coverageAlpha = range.getCoverage() / maxCoverage;
if (coverageAlpha < 1.0)
{
for (int x = range.getXPos(); x < range.getXPosEnd(); x++)
{
pixel = alphaRaster.getSample(x, y, 0);
pixel = (int) (pixel * coverageAlpha);
alphaRaster.setSample(x, y, 0, pixel);
}
}
}
ColorModel paintColorModel = pCtx.getColorModel();
CompositeContext cCtx = composite.createContext(paintColorModel,
getColorModel(),
renderingHints);
WritableRaster raster = getDestinationRaster();
WritableRaster targetChild = raster.createWritableTranslatedChild(-x0, -y);
cCtx.compose(paintRaster, targetChild, targetChild);
updateRaster(raster, x0, y, x1 - x0, 1);
cCtx.dispose();
}
/**
* Initializes this graphics object. This must be called by subclasses in
* order to correctly initialize the state of this object.
*/
protected void init()
{
setPaint(Color.BLACK);
setFont(FONT);
isOptimized = true;
}
/**
* Returns a WritableRaster that is used by this class to perform the
* rendering in. It is not necessary that the target surface immediately
* reflects changes in the raster. Updates to the raster are notified via
* {@link #updateRaster}.
*
* @return the destination raster
*/
protected WritableRaster getDestinationRaster()
{
// TODO: Ideally we would fetch the xdrawable's surface pixels for
// initialization of the raster.
Rectangle db = getDeviceBounds();
if (destinationRaster == null)
{
int[] bandMasks = new int[]{ 0xFF0000, 0xFF00, 0xFF };
destinationRaster = Raster.createPackedRaster(DataBuffer.TYPE_INT,
db.width, db.height,
bandMasks, null);
// Initialize raster with white.
int x0 = destinationRaster.getMinX();
int x1 = destinationRaster.getWidth() + x0;
int y0 = destinationRaster.getMinY();
int y1 = destinationRaster.getHeight() + y0;
int numBands = destinationRaster.getNumBands();
for (int y = y0; y < y1; y++)
{
for (int x = x0; x < x1; x++)
{
for (int b = 0; b < numBands; b++)
destinationRaster.setSample(x, y, b, 255);
}
}
}
return destinationRaster;
}
/**
* Notifies the backend that the raster has changed in the specified
* rectangular area. The raster that is provided in this method is always
* the same as the one returned in {@link #getDestinationRaster}.
* Backends that reflect changes to this raster directly don't need to do
* anything here.
*
* @param raster the updated raster, identical to the raster returned
* by {@link #getDestinationRaster()}
* @param x the upper left corner of the updated region, X coordinate
* @param y the upper lef corner of the updated region, Y coordinate
* @param w the width of the updated region
* @param h the height of the updated region
*/
protected void updateRaster(Raster raster, int x, int y, int w, int h)
{
// Nothing to do here. Backends that need to update their surface
// to reflect the change should override this method.
}
// Some helper methods.
/**
* Helper method to check and update the optimization conditions.
*/
private void updateOptimization()
{
int transformType = transform.getType();
boolean optimizedTransform = false;
if (transformType == AffineTransform.TYPE_IDENTITY
|| transformType == AffineTransform.TYPE_TRANSLATION)
optimizedTransform = true;
boolean optimizedClip = (clip == null || clip instanceof Rectangle);
isOptimized = optimizedClip
&& optimizedTransform && paint instanceof Color
&& composite == AlphaComposite.SrcOver
&& stroke.equals(new BasicStroke());
}
/**
* Calculates the intersection of two rectangles. The result is stored
* in rect. This is basically the same
* like {@link Rectangle#intersection(Rectangle)}, only that it does not
* create new Rectangle instances. The tradeoff is that you loose any data in
* rect.
*
* @param x upper-left x coodinate of first rectangle
* @param y upper-left y coodinate of first rectangle
* @param w width of first rectangle
* @param h height of first rectangle
* @param rect a Rectangle object of the second rectangle
*
* @throws NullPointerException if rect is null
*
* @return a rectangle corresponding to the intersection of the
* two rectangles. An empty rectangle is returned if the rectangles
* do not overlap
*/
private static Rectangle computeIntersection(int x, int y, int w, int h,
Rectangle rect)
{
int x2 = rect.x;
int y2 = rect.y;
int w2 = rect.width;
int h2 = rect.height;
int dx = (x > x2) ? x : x2;
int dy = (y > y2) ? y : y2;
int dw = (x + w < x2 + w2) ? (x + w - dx) : (x2 + w2 - dx);
int dh = (y + h < y2 + h2) ? (y + h - dy) : (y2 + h2 - dy);
if (dw >= 0 && dh >= 0)
rect.setBounds(dx, dy, dw, dh);
else
rect.setBounds(0, 0, 0, 0);
return rect;
}
/**
* Helper method to transform the clip. This is called by the various
* transformation-manipulation methods to update the clip (which is in
* userspace) accordingly.
*
* The transform usually is the inverse transform that was applied to the
* graphics object.
*
* @param t the transform to apply to the clip
*/
private void updateClip(AffineTransform t)
{
if (! (clip instanceof GeneralPath))
clip = new GeneralPath(clip);
GeneralPath p = (GeneralPath) clip;
p.transform(t);
}
/**
* Returns a free scanline converter from the pool.
*
* @return a scanline converter
*/
private ScanlineConverter getScanlineConverter()
{
synchronized (scanlineConverters)
{
ScanlineConverter sc;
if (scanlineConverters.size() > 0)
{
sc = scanlineConverters.removeFirst();
}
else
{
sc = new ScanlineConverter();
}
return sc;
}
}
/**
* Puts a scanline converter back in the pool.
*
* @param sc
*/
private void freeScanlineConverter(ScanlineConverter sc)
{
synchronized (scanlineConverters)
{
scanlineConverters.addLast(sc);
}
}
private PaintContext getPaintContext()
{
if (this.paintContext == null)
{
this.paintContext =
this.foreground.createContext(getColorModel(),
getDeviceBounds(),
getClipBounds(),
getTransform(),
getRenderingHints());
}
return this.paintContext;
}
/**
* Scales an image to the specified width and height. This should also
* be used to implement
* {@link Toolkit#prepareImage(Image, int, int, ImageObserver)}.
* This uses {@link Toolkit#createImage(ImageProducer)} to create the actual
* image.
*
* @param image the image to prepare
* @param w the width
* @param h the height
*
* @return the scaled image
*/
public static Image prepareImage(Image image, int w, int h)
{
// Try to find cached scaled image.
HashMap