/*
* 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 org.apache.harmony.awt.gl;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Paint;
import java.awt.PaintContext;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.Toolkit;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.image.AffineTransformOp;
import java.awt.image.ImageObserver;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.WritableRaster;
import java.awt.image.renderable.RenderableImage;
import java.awt.geom.AffineTransform;
import java.awt.geom.Arc2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.PathIterator;
import java.awt.geom.RoundRectangle2D;
import java.text.AttributedCharacterIterator;
import java.util.Map;
import org.apache.harmony.awt.gl.Surface;
import org.apache.harmony.awt.gl.image.OffscreenImage;
import org.apache.harmony.awt.gl.render.Blitter;
import org.apache.harmony.awt.gl.render.JavaArcRasterizer;
import org.apache.harmony.awt.gl.render.JavaLineRasterizer;
import org.apache.harmony.awt.gl.render.JavaShapeRasterizer;
import org.apache.harmony.awt.gl.render.JavaTextRenderer;
import org.apache.harmony.awt.gl.render.NullBlitter;
/*
* List of abstract methods to implement in subclusses
* Graphics.copyArea(int x, int y, int width, int height, int dx, int dy)
* Graphics.create()
* Graphics2D.getDeviceConfiguration()
* CommonGraphics2D.fillMultiRectAreaColor(MultiRectArea mra);
* CommonGraphics2D.fillMultiRectAreaPaint(MultiRectArea mra);
*/
/**
* CommonGraphics2D class is a super class for all system-dependent
* implementations. It implements major part of Graphics and Graphics2D
* abstract methods.
* <h2>CommonGraphics2D Class Internals</h2>
* <h3>Line and Shape Rasterizers</h3>
* <p>
* The CommonGraphics2D class splits all shapes into a set of rectangles
* to unify the drawing process for different operating systems and architectures.
* For this purpose Java 2D* uses the JavaShapeRasterizer and the JavaLineRasterizer
* classes from the org.apache.harmony.awt.gl.render package. The JavaShapeRasterizer
* class splits an object implementing a Shape interface into a set of rectangles and
* produces a MultiRectArea object. The JavaLineRasterizer class makes line drawing
* more accurate and processes lines with strokes, which are instances of the BasicStroke
* class.
* </p>
* <p>
* To port the shape drawing to another platform you just need to override
* rectangle-drawing methods. However, if your operating system has functions to draw
* particular shapes, you can optimize your subclass of the CommonGraphics2D class by
* using this functionality in overridden methods.
* </p>
* <h3>Blitters</h3>
* <p>
* Blitter classes draw images on the display or buffered images. All blitters inherit
* the org.apache.harmony.awt.gl.render.Blitter interface.
* </p>
* <p>Blitters are divided into:
* <ul>
* <li>Native blitters for simple types of images, which the underlying native library
* can draw.</li>
* <li>Java* blitters for those types of images, which the underlying native library
* cannot handle.</li>
* </ul></p>
* <p>
* DRL Java 2D* also uses blitters to fill the shapes and the user-defined subclasses
* of the java.awt.Paint class with paints, which the system does not support.
* </p>
*
*<h3>Text Renderers</h3>
*<p>
*Text renderers draw strings and glyph vectors. All text renderers are subclasses
*of the org.apache.harmony.awt.gl.TextRenderer class.
*</p>
*
*/
public abstract class CommonGraphics2D extends Graphics2D {
protected Surface dstSurf = null;
protected Blitter blitter = NullBlitter.getInstance();
protected RenderingHints hints = new RenderingHints(null);
// Clipping things
protected MultiRectArea clip = null;
protected Paint paint = Color.WHITE;
protected Color fgColor = Color.WHITE;
protected Color bgColor = Color.BLACK;
protected Composite composite = AlphaComposite.SrcOver;
protected Stroke stroke = new BasicStroke();
//TODO: Think more about FontRenderContext
protected FontRenderContext frc = new FontRenderContext(null, false, false);
protected JavaShapeRasterizer jsr = new JavaShapeRasterizer();
protected Font font = new Font("Dialog", Font.PLAIN, 12);; //$NON-NLS-1$
protected TextRenderer jtr = JavaTextRenderer.inst;
// Current graphics transform
protected AffineTransform transform = new AffineTransform();
protected double[] matrix = new double[6];
// Original user->device translation as transform and point
//public AffineTransform origTransform = new AffineTransform();
public Point origPoint = new Point(0, 0);
// Print debug output or not
protected static final boolean debugOutput = "1".equals(System.getProperty("g2d.debug")); //$NON-NLS-1$ //$NON-NLS-2$
// Constructors
protected CommonGraphics2D() {
}
protected CommonGraphics2D(int tx, int ty) {
this(tx, ty, null);
}
protected CommonGraphics2D(int tx, int ty, MultiRectArea clip) {
setTransform(AffineTransform.getTranslateInstance(tx, ty));
//origTransform = AffineTransform.getTranslateInstance(tx, ty);
origPoint = new Point(tx, ty);
setClip(clip);
}
// Public methods
@Override
public void addRenderingHints(Map<?,?> hints) {
this.hints.putAll(hints);
}
@Override
public void clearRect(int x, int y, int width, int height) {
Color c = getColor();
Paint p = getPaint();
setColor(getBackground());
fillRect(x, y, width, height);
setColor(c);
setPaint(p);
if (debugOutput) {
System.err.println("CommonGraphics2D.clearRect("+x+", "+y+", "+width+", "+height+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
}
}
@Override
public void clipRect(int x, int y, int width, int height) {
clip(new Rectangle(x, y, width, height));
}
@Override
public void clip(Shape s) {
if (s == null) {
clip = null;
return;
}
MultiRectArea mra = null;
if (s instanceof MultiRectArea) {
mra = new MultiRectArea((MultiRectArea)s);
mra.translate((int)transform.getTranslateX(), (int)transform.getTranslateY());
} else {
int type = transform.getType();
if(s instanceof Rectangle && (type & (AffineTransform.TYPE_IDENTITY |
AffineTransform.TYPE_TRANSLATION)) != 0){
mra = new MultiRectArea((Rectangle)s);
if(type == AffineTransform.TYPE_TRANSLATION){
mra.translate((int)transform.getTranslateX(), (int)transform.getTranslateY());
}
} else {
s = transform.createTransformedShape(s);
mra = jsr.rasterize(s, 0.5);
}
}
if (clip == null) {
setTransformedClip(mra);
} else {
clip.intersect(mra);
setTransformedClip(clip);
}
}
@Override
public void dispose() {
// Do nothing for Java only classes
}
/***************************************************************************
*
* Draw methods
*
***************************************************************************/
@Override
public void draw(Shape s) {
if (stroke instanceof BasicStroke && ((BasicStroke)stroke).getLineWidth() <= 1) {
//TODO: Think about drawing the shape in one fillMultiRectArea call
BasicStroke bstroke = (BasicStroke)stroke;
JavaLineRasterizer.LineDasher ld = (bstroke.getDashArray() == null)?null:new JavaLineRasterizer.LineDasher(bstroke.getDashArray(), bstroke.getDashPhase());
PathIterator pi = s.getPathIterator(transform, 0.5);
float []points = new float[6];
int x1 = Integer.MIN_VALUE;
int y1 = Integer.MIN_VALUE;
int cx1 = Integer.MIN_VALUE;
int cy1 = Integer.MIN_VALUE;
while (!pi.isDone()) {
switch (pi.currentSegment(points)) {
case PathIterator.SEG_MOVETO:
x1 = (int)Math.floor(points[0]);
y1 = (int)Math.floor(points[1]);
cx1 = x1;
cy1 = y1;
break;
case PathIterator.SEG_LINETO:
int x2 = (int)Math.floor(points[0]);
int y2 = (int)Math.floor(points[1]);
fillMultiRectArea(JavaLineRasterizer.rasterize(x1, y1, x2, y2, null, ld, false));
x1 = x2;
y1 = y2;
break;
case PathIterator.SEG_CLOSE:
x2 = cx1;
y2 = cy1;
fillMultiRectArea(JavaLineRasterizer.rasterize(x1, y1, x2, y2, null, ld, false));
x1 = x2;
y1 = y2;
break;
}
pi.next();
}
} else {
s = stroke.createStrokedShape(s);
s = transform.createTransformedShape(s);
fillMultiRectArea(jsr.rasterize(s, 0.5));
}
}
@Override
public void drawArc(int x, int y, int width, int height, int sa, int ea) {
if (stroke instanceof BasicStroke && ((BasicStroke)stroke).getLineWidth() <= 1 &&
((BasicStroke)stroke).getDashArray() == null &&
(transform.isIdentity() || transform.getType() == AffineTransform.TYPE_TRANSLATION)) {
Point p = new Point(x, y);
transform.transform(p, p);
MultiRectArea mra = JavaArcRasterizer.rasterize(x, y, width, height, sa, ea, clip);
fillMultiRectArea(mra);
return;
}
draw(new Arc2D.Float(x, y, width, height, sa, ea, Arc2D.OPEN));
}
@Override
public boolean drawImage(Image image, int x, int y, Color bgcolor,
ImageObserver imageObserver) {
if(image == null) {
return true;
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h, (AffineTransform) transform.clone(),
composite, bgcolor, clip);
}
return done;
}
@Override
public boolean drawImage(Image image, int x, int y, ImageObserver imageObserver) {
return drawImage(image, x, y, null, imageObserver);
}
@Override
public boolean drawImage(Image image, int x, int y, int width, int height,
Color bgcolor, ImageObserver imageObserver) {
if(image == null) {
return true;
}
if(width == 0 || height == 0) {
return true;
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
if(w == width && h == height){
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(),
composite, bgcolor, clip);
}else{
AffineTransform xform = new AffineTransform();
xform.setToScale((float)width / w, (float)height / h);
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(),
xform, composite, bgcolor, clip);
}
}
return done;
}
@Override
public boolean drawImage(Image image, int x, int y, int width, int height,
ImageObserver imageObserver) {
return drawImage(image, x, y, width, height, null, imageObserver);
}
@Override
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2, Color bgcolor,
ImageObserver imageObserver) {
if(image == null) {
return true;
}
if(dx1 == dx2 || dy1 == dy2 || sx1 == sx2 || sy1 == sy2) {
return true;
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int dstX = dx1;
int dstY = dy1;
int srcX = sx1;
int srcY = sy1;
int dstW = dx2 - dx1;
int dstH = dy2 - dy1;
int srcW = sx2 - sx1;
int srcH = sy2 - sy1;
if(srcW == dstW && srcH == dstH){
blitter.blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, srcW, srcH,
(AffineTransform) transform.clone(),
composite, bgcolor, clip);
}else{
AffineTransform xform = new AffineTransform();
xform.setToScale((float)dstW / srcW, (float)dstH / srcH);
blitter.blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, srcW, srcH,
(AffineTransform) transform.clone(),
xform, composite, bgcolor, clip);
}
}
return done;
}
@Override
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2, ImageObserver imageObserver) {
return drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
imageObserver);
}
@Override
public void drawImage(BufferedImage bufImage, BufferedImageOp op,
int x, int y) {
if(bufImage == null) {
return;
}
if(op == null) {
drawImage(bufImage, x, y, null);
} else if(op instanceof AffineTransformOp){
AffineTransformOp atop = (AffineTransformOp) op;
AffineTransform xform = atop.getTransform();
Surface srcSurf = Surface.getImageSurface(bufImage);
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(), xform,
composite, null, clip);
} else {
bufImage = op.filter(bufImage, null);
Surface srcSurf = Surface.getImageSurface(bufImage);
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(),
composite, null, clip);
}
}
@Override
public boolean drawImage(Image image, AffineTransform trans,
ImageObserver imageObserver) {
if(image == null) {
return true;
}
if(trans == null || trans.isIdentity()) {
return drawImage(image, 0, 0, imageObserver);
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
AffineTransform xform = (AffineTransform) transform.clone();
xform.concatenate(trans);
blitter.blit(0, 0, srcSurf, 0, 0, dstSurf, w, h, xform, composite,
null, clip);
}
return done;
}
@Override
public void drawLine(int x1, int y1, int x2, int y2) {
if (debugOutput) {
System.err.println("CommonGraphics2D.drawLine("+x1+", "+y1+", "+x2+", "+y2+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
}
if (stroke instanceof BasicStroke && ((BasicStroke)stroke).getLineWidth() <= 1) {
BasicStroke bstroke = (BasicStroke)stroke;
Point p1 = new Point(x1, y1);
Point p2 = new Point(x2, y2);
transform.transform(p1, p1);
transform.transform(p2, p2);
JavaLineRasterizer.LineDasher ld = (bstroke.getDashArray() == null)?null:new JavaLineRasterizer.LineDasher(bstroke.getDashArray(), bstroke.getDashPhase());
MultiRectArea mra = JavaLineRasterizer.rasterize(p1.x, p1.y, p2.x, p2.y, null, ld, false);
fillMultiRectArea(mra);
return;
}
draw(new Line2D.Float(x1, y1, x2, y2));
}
@Override
public void drawOval(int x, int y, int width, int height) {
if (stroke instanceof BasicStroke && ((BasicStroke)stroke).getLineWidth() <= 1 &&
((BasicStroke)stroke).getDashArray() == null &&
(transform.isIdentity() || transform.getType() == AffineTransform.TYPE_TRANSLATION)) {
Point p = new Point(x, y);
transform.transform(p, p);
MultiRectArea mra = JavaArcRasterizer.rasterize(x, y, width, height, 0, 360, clip);
fillMultiRectArea(mra);
return;
}
draw(new Ellipse2D.Float(x, y, width, height));
}
@Override
public void drawPolygon(int[] xpoints, int[] ypoints, int npoints) {
draw(new Polygon(xpoints, ypoints, npoints));
}
@Override
public void drawPolygon(Polygon polygon) {
draw(polygon);
}
@Override
public void drawPolyline(int[] xpoints, int[] ypoints, int npoints) {
for (int i = 0; i < npoints-1; i++) {
drawLine(xpoints[i], ypoints[i], xpoints[i+1], ypoints[i+1]);
}
}
@Override
public void drawRenderableImage(RenderableImage img, AffineTransform xform) {
if (img == null) {
return;
}
double scaleX = xform.getScaleX();
double scaleY = xform.getScaleY();
if (scaleX == 1 && scaleY == 1) {
drawRenderedImage(img.createDefaultRendering(), xform);
} else {
int width = (int)Math.round(img.getWidth()*scaleX);
int height = (int)Math.round(img.getHeight()*scaleY);
xform = (AffineTransform)xform.clone();
xform.scale(1, 1);
drawRenderedImage(img.createScaledRendering(width, height, null), xform);
}
}
@Override
public void drawRenderedImage(RenderedImage rimg, AffineTransform xform) {
if (rimg == null) {
return;
}
Image img = null;
if (rimg instanceof Image) {
img = (Image)rimg;
} else {
//TODO: Create new class to provide Image interface for RenderedImage or rewrite this method
img = new BufferedImage(rimg.getColorModel(), rimg.copyData(null), false, null);
}
drawImage(img, xform, null);
}
@Override
public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
if (debugOutput) {
System.err.println("CommonGraphics2D.drawRoundRect("+x+", "+y+", "+width+", "+height+","+arcWidth+", "+arcHeight+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
}
draw(new RoundRectangle2D.Float(x, y, width, height, arcWidth, arcHeight));
}
/***************************************************************************
*
* String methods
*
***************************************************************************/
@Override
public void drawString(AttributedCharacterIterator iterator, float x, float y) {
GlyphVector gv = font.createGlyphVector(frc, iterator);
drawGlyphVector(gv, x, y);
}
@Override
public void drawString(AttributedCharacterIterator iterator, int x, int y) {
drawString(iterator, (float)x, (float)y);
}
@Override
public void drawString(String str, int x, int y) {
drawString(str, (float)x, (float)y);
}
@Override
public void drawString(String str, float x, float y) {
if (debugOutput) {
System.err.println("CommonGraphics2D.drawString("+str+", "+x+", "+y+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
}
AffineTransform at = (AffineTransform)this.getTransform().clone();
AffineTransform fontTransform = font.getTransform();
at.concatenate(fontTransform);
double[] matrix = new double[6];
if (!at.isIdentity()){
int atType = at.getType();
at.getMatrix(matrix);
// TYPE_TRANSLATION
if (atType == AffineTransform.TYPE_TRANSLATION){
jtr.drawString(this, str,
(float)(x+fontTransform.getTranslateX()),
(float)(y+fontTransform.getTranslateY()));
return;
}
// TODO: we use slow type of drawing strings when Font object
// in Graphics has transforms, we just fill outlines. New textrenderer
// is to be implemented.
Shape sh = font.createGlyphVector(this.getFontRenderContext(), str).getOutline(x, y);
this.fill(sh);
} else {
jtr.drawString(this, str, x, y);
}
}
@Override
public void drawGlyphVector(GlyphVector gv, float x, float y) {
AffineTransform at = gv.getFont().getTransform();
double[] matrix = new double[6];
if ((at != null) && (!at.isIdentity())){
int atType = at.getType();
at.getMatrix(matrix);
// TYPE_TRANSLATION
if ((atType == AffineTransform.TYPE_TRANSLATION) &&
((gv.getLayoutFlags() & GlyphVector.FLAG_HAS_TRANSFORMS) == 0)){
jtr.drawGlyphVector(this, gv, (int)(x+matrix[4]), (int)(y+matrix[5]));
return;
}
} else {
if (((gv.getLayoutFlags() & GlyphVector.FLAG_HAS_TRANSFORMS) == 0)){
jtr.drawGlyphVector(this, gv, x, y);
return;
}
}
// TODO: we use slow type of drawing strings when Font object
// in Graphics has transforms, we just fill outlines. New textrenderer
// is to be implemented.
Shape sh = gv.getOutline(x, y);
this.fill(sh);
}
/***************************************************************************
*
* Fill methods
*
***************************************************************************/
@Override
public void fill(Shape s) {
s = transform.createTransformedShape(s);
MultiRectArea mra = jsr.rasterize(s, 0.5);
fillMultiRectArea(mra);
}
@Override
public void fillArc(int x, int y, int width, int height, int sa, int ea) {
fill(new Arc2D.Float(x, y, width, height, sa, ea, Arc2D.PIE));
}
@Override
public void fillOval(int x, int y, int width, int height) {
fill(new Ellipse2D.Float(x, y, width, height));
}
@Override
public void fillPolygon(int[] xpoints, int[] ypoints, int npoints) {
fill(new Polygon(xpoints, ypoints, npoints));
}
@Override
public void fillPolygon(Polygon polygon) {
fill(polygon);
}
@Override
public void fillRect(int x, int y, int width, int height) {
if (debugOutput) {
System.err.println("CommonGraphics2D.fillRect("+x+", "+y+", "+width+", "+height+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
}
fill(new Rectangle(x, y, width, height));
}
@Override
public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
if (debugOutput) {
System.err.println("CommonGraphics2D.fillRoundRect("+x+", "+y+", "+width+", "+height+","+arcWidth+", "+arcHeight+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
}
fill(new RoundRectangle2D.Float(x, y, width, height, arcWidth, arcHeight));
}
/***************************************************************************
*
* Get methods
*
***************************************************************************/
@Override
public Color getBackground() {
return bgColor;
}
@Override
public Shape getClip() {
if (clip == null) {
return null;
}
MultiRectArea res = new MultiRectArea(clip);
res.translate(-Math.round((float)transform.getTranslateX()), -Math.round((float)transform.getTranslateY()));
return res;
}
@Override
public Rectangle getClipBounds() {
if (clip == null) {
return null;
}
Rectangle res = (Rectangle) clip.getBounds().clone();
res.translate(-Math.round((float)transform.getTranslateX()), -Math.round((float)transform.getTranslateY()));
return res;
}
@Override
public Color getColor() {
return fgColor;
}
@Override
public Composite getComposite() {
return composite;
}
@Override
public Font getFont() {
return font;
}
@SuppressWarnings("deprecation")
@Override
public FontMetrics getFontMetrics(Font font) {
return Toolkit.getDefaultToolkit().getFontMetrics(font);
}
@Override
public FontRenderContext getFontRenderContext() {
return frc;
}
@Override
public Paint getPaint() {
return paint;
}
@Override
public Object getRenderingHint(RenderingHints.Key key) {
return hints.get(key);
}
@Override
public RenderingHints getRenderingHints() {
return hints;
}
@Override
public Stroke getStroke() {
return stroke;
}
@Override
public AffineTransform getTransform() {
return (AffineTransform)transform.clone();
}
@Override
public boolean hit(Rectangle rect, Shape s, boolean onStroke) {
//TODO: Implement method....
return false;
}
/***************************************************************************
*
* Transformation methods
*
***************************************************************************/
@Override
public void rotate(double theta) {
transform.rotate(theta);
transform.getMatrix(matrix);
}
@Override
public void rotate(double theta, double x, double y) {
transform.rotate(theta, x, y);
transform.getMatrix(matrix);
}
@Override
public void scale(double sx, double sy) {
transform.scale(sx, sy);
transform.getMatrix(matrix);
}
@Override
public void shear(double shx, double shy) {
transform.shear(shx, shy);
transform.getMatrix(matrix);
}
@Override
public void transform(AffineTransform at) {
transform.concatenate(at);
transform.getMatrix(matrix);
}
@Override
public void translate(double tx, double ty) {
if (debugOutput) {
System.err.println("CommonGraphics2D.translate("+tx+", "+ty+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
transform.translate(tx, ty);
transform.getMatrix(matrix);
}
@Override
public void translate(int tx, int ty) {
if (debugOutput) {
System.err.println("CommonGraphics2D.translate("+tx+", "+ty+")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
transform.translate(tx, ty);
transform.getMatrix(matrix);
}
/***************************************************************************
*
* Set methods
*
***************************************************************************/
@Override
public void setBackground(Color color) {
bgColor = color;
}
@Override
public void setClip(int x, int y, int width, int height) {
setClip(new Rectangle(x, y, width, height));
}
@Override
public void setClip(Shape s) {
if (s == null) {
setTransformedClip(null);
if (debugOutput) {
System.err.println("CommonGraphics2D.setClip(null)"); //$NON-NLS-1$
}
return;
}
if (debugOutput) {
System.err.println("CommonGraphics2D.setClip("+s.getBounds()+")"); //$NON-NLS-1$ //$NON-NLS-2$
}
if (s instanceof MultiRectArea) {
MultiRectArea nclip = new MultiRectArea((MultiRectArea)s);
nclip.translate(Math.round((float)transform.getTranslateX()), Math.round((float)transform.getTranslateY()));
setTransformedClip(nclip);
} else {
int type = transform.getType();
if(s instanceof Rectangle && (type & (AffineTransform.TYPE_IDENTITY |
AffineTransform.TYPE_TRANSLATION)) != 0){
MultiRectArea nclip = new MultiRectArea((Rectangle)s);
if(type == AffineTransform.TYPE_TRANSLATION){
nclip.translate((int)transform.getTranslateX(), (int)transform.getTranslateY());
}
setTransformedClip(nclip);
} else {
s = transform.createTransformedShape(s);
setTransformedClip(jsr.rasterize(s, 0.5));
}
}
}
@Override
public void setColor(Color color) {
if (color != null) {
fgColor = color;
paint = color;
}
}
@Override
public void setComposite(Composite composite) {
this.composite = composite;
}
@Override
public void setFont(Font font) {
this.font = font;
}
@Override
public void setPaint(Paint paint) {
if (paint == null)
return;
this.paint = paint;
if (paint instanceof Color) {
fgColor = (Color)paint;
}
}
@Override
public void setPaintMode() {
composite = AlphaComposite.SrcOver;
}
@Override
public void setRenderingHint(RenderingHints.Key key, Object value) {
hints.put(key, value);
}
@Override
public void setRenderingHints(Map<?,?> hints) {
this.hints.clear();
this.hints.putAll(hints);
}
@Override
public void setStroke(Stroke stroke) {
this.stroke = stroke;
}
@Override
public void setTransform(AffineTransform transform) {
this.transform = transform;
transform.getMatrix(matrix);
}
@Override
public void setXORMode(Color color) {
composite = new XORComposite(color);
}
// Protected methods
protected void setTransformedClip(MultiRectArea clip) {
this.clip = clip;
}
/**
* This method fills the given MultiRectArea with current paint.
* It calls fillMultiRectAreaColor and fillMultiRectAreaPaint
* methods depending on the type of current paint.
* @param mra MultiRectArea to fill
*/
protected void fillMultiRectArea(MultiRectArea mra) {
if (clip != null) {
mra.intersect(clip);
}
// Return if all stuff is clipped
if (mra.rect[0] < 5) {
return;
}
if (debugOutput) {
System.err.println("CommonGraphics2D.fillMultiRectArea("+mra+")"); //$NON-NLS-1$ //$NON-NLS-2$
}
if (paint instanceof Color){
fillMultiRectAreaColor(mra);
}else{
fillMultiRectAreaPaint(mra);
}
}
/**
* This method fills the given MultiRectArea with solid color.
* @param mra MultiRectArea to fill
*/
protected void fillMultiRectAreaColor(MultiRectArea mra) {
fillMultiRectAreaPaint(mra);
}
/**
* This method fills the given MultiRectArea with any paint.
* @param mra MultiRectArea to fill
*/
protected void fillMultiRectAreaPaint(MultiRectArea mra) {
Rectangle rec = mra.getBounds();
int x = rec.x;
int y = rec.y;
int w = rec.width;
int h = rec.height;
if(w <= 0 || h <= 0) {
return;
}
PaintContext pc = paint.createContext(null, rec, rec, transform, hints);
Raster r = pc.getRaster(x, y, w, h);
WritableRaster wr;
if(r instanceof WritableRaster){
wr = (WritableRaster) r;
}else{
wr = r.createCompatibleWritableRaster();
wr.setRect(r);
}
Surface srcSurf = new ImageSurface(pc.getColorModel(), wr);
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
composite, null, mra);
srcSurf.dispose();
}
/**
* Copies graphics class fields.
* Used in create method
*
* @param copy Graphics class to copy
*/
protected void copyInternalFields(CommonGraphics2D copy) {
if (clip == null) {
copy.setTransformedClip(null);
} else {
copy.setTransformedClip(new MultiRectArea(clip));
}
copy.setBackground(bgColor);
copy.setColor(fgColor);
copy.setPaint(paint);
copy.setComposite(composite);
copy.setStroke(stroke);
copy.setFont(font);
copy.setTransform(new AffineTransform(transform));
//copy.origTransform = new AffineTransform(origTransform);
copy.origPoint = new Point(origPoint);
}
}