609 lines
17 KiB
Java
609 lines
17 KiB
Java
/*************************************************************************
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: BufferedGraphics2D.java,v $
|
|
*
|
|
* $Revision: 1.3 $
|
|
*
|
|
* last change: $Author: rt $ $Date: 2005-09-07 23:08:14 $
|
|
*
|
|
* The Contents of this file are made available subject to
|
|
* the terms of GNU Lesser General Public License Version 2.1.
|
|
*
|
|
*
|
|
* GNU Lesser General Public License Version 2.1
|
|
* =============================================
|
|
* Copyright 2005 by Sun Microsystems, Inc.
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
************************************************************************/
|
|
|
|
// Java AWT
|
|
import java.awt.*;
|
|
import java.awt.geom.*;
|
|
import java.awt.image.*;
|
|
import java.awt.image.renderable.*;
|
|
import java.awt.font.*;
|
|
import java.text.*;
|
|
import java.util.*;
|
|
|
|
|
|
public class BufferedGraphics2D
|
|
extends java.awt.Graphics2D
|
|
{
|
|
// TODO: Somehow, get rid of this duplicate graphics (the graphics member,
|
|
// and this object itself, extending a Graphics2D)
|
|
private Graphics2D graphics;
|
|
private BufferedImage backBuffer;
|
|
private Graphics2D backBufferGraphics;
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
public BufferedGraphics2D( java.awt.Graphics2D _graphics, int width, int height )
|
|
{
|
|
setGraphics( _graphics, Math.max(1,width), Math.max(1,height) );
|
|
}
|
|
|
|
public void redraw( Graphics2D graph )
|
|
{
|
|
if( graph != null &&
|
|
backBuffer != null )
|
|
{
|
|
CanvasUtils.printLog("BufferedGraphics2D.redraw: using buffer of size (" +
|
|
backBuffer.getWidth() + "," + backBuffer.getHeight() + ")" );
|
|
|
|
// set transform to identity
|
|
graph.setTransform( new AffineTransform() );
|
|
graph.drawImage(backBuffer, 0, 0, null);
|
|
CanvasUtils.postRenderImageTreatment( backBuffer );
|
|
}
|
|
}
|
|
|
|
public BufferedImage getBackBuffer()
|
|
{
|
|
return backBuffer;
|
|
}
|
|
|
|
public void setSize( int width, int height )
|
|
{
|
|
if( backBuffer != null &&
|
|
width == backBuffer.getWidth() &&
|
|
height == backBuffer.getHeight() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( backBufferGraphics != null )
|
|
backBufferGraphics.dispose();
|
|
|
|
if( backBuffer != null )
|
|
backBuffer.flush();
|
|
|
|
// TODO: Maybe VolatileImage with another BufferedImage as a backup is
|
|
// a tad faster here.
|
|
backBuffer = graphics.getDeviceConfiguration().createCompatibleImage(width,
|
|
height);
|
|
|
|
backBufferGraphics = backBuffer.createGraphics();
|
|
CanvasUtils.initGraphics( backBufferGraphics );
|
|
|
|
// clear the buffer to white (to have a defined state here)
|
|
backBufferGraphics.setColor( java.awt.Color.white );
|
|
backBufferGraphics.fillRect( 0,0,width,height );
|
|
}
|
|
|
|
public void setGraphics( Graphics2D _graphics, int width, int height )
|
|
{
|
|
if( graphics != null )
|
|
graphics.dispose();
|
|
|
|
graphics = _graphics;
|
|
|
|
setSize(width,height);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
//
|
|
// Graphics
|
|
// ========
|
|
//
|
|
public void clearRect(int x, int y, int width, int height)
|
|
{
|
|
graphics.clearRect(x,y,width,height);
|
|
backBufferGraphics.clearRect(x,y,width,height);
|
|
}
|
|
|
|
public void clipRect(int x, int y, int width, int height)
|
|
{
|
|
graphics.clipRect(x,y,width,height);
|
|
backBufferGraphics.clipRect(x,y,width,height);
|
|
}
|
|
|
|
public void copyArea(int x, int y, int width, int height, int dx, int dy)
|
|
{
|
|
graphics.copyArea(x,y,width,height,dx,dy);
|
|
backBufferGraphics.copyArea(x,y,width,height,dx,dy);
|
|
}
|
|
|
|
public Graphics create()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public Graphics create(int x, int y, int width, int height)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public void dispose()
|
|
{
|
|
graphics.dispose();
|
|
backBufferGraphics.dispose();
|
|
backBuffer.flush();
|
|
}
|
|
|
|
public void draw3DRect(int x, int y, int width, int height, boolean raised)
|
|
{
|
|
graphics.draw3DRect(x,y,width,height,raised);
|
|
backBufferGraphics.draw3DRect(x,y,width,height,raised);
|
|
}
|
|
|
|
public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
|
|
{
|
|
graphics.drawArc(x,y,width,height,startAngle,arcAngle);
|
|
backBufferGraphics.drawArc(x,y,width,height,startAngle,arcAngle);
|
|
}
|
|
|
|
public void drawBytes(byte[] data, int offset, int length, int x, int y)
|
|
{
|
|
graphics.drawBytes(data,offset,length,x,y);
|
|
backBufferGraphics.drawBytes(data,offset,length,x,y);
|
|
}
|
|
|
|
public void drawChars(char[] data, int offset, int length, int x, int y)
|
|
{
|
|
graphics.drawChars(data,offset,length,x,y);
|
|
backBufferGraphics.drawChars(data,offset,length,x,y);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer)
|
|
{
|
|
backBufferGraphics.drawImage(img,x,y,bgcolor,observer);
|
|
return graphics.drawImage(img,x,y,bgcolor,observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, ImageObserver observer)
|
|
{
|
|
backBufferGraphics.drawImage(img,x,y,observer);
|
|
return graphics.drawImage(img,x,y,observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer)
|
|
{
|
|
backBufferGraphics.drawImage(img,x,y,width,height,bgcolor,observer);
|
|
return graphics.drawImage(img,x,y,width,height,bgcolor,observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)
|
|
{
|
|
backBufferGraphics.drawImage(img,x,y,width,height,observer);
|
|
return graphics.drawImage(img,x,y,width,height,observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer)
|
|
{
|
|
backBufferGraphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,bgcolor,observer);
|
|
return graphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,bgcolor,observer);
|
|
}
|
|
|
|
public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer)
|
|
{
|
|
backBufferGraphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,observer);
|
|
return graphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,observer);
|
|
}
|
|
|
|
public void drawLine(int x1, int y1, int x2, int y2)
|
|
{
|
|
graphics.drawLine(x1,y1,x2,y2);
|
|
backBufferGraphics.drawLine(x1,y1,x2,y2);
|
|
}
|
|
|
|
public void drawOval(int x, int y, int width, int height)
|
|
{
|
|
graphics.drawOval(x,y,width,height);
|
|
backBufferGraphics.drawOval(x,y,width,height);
|
|
}
|
|
|
|
public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
|
|
{
|
|
graphics.drawPolygon(xPoints,yPoints,nPoints);
|
|
backBufferGraphics.drawPolygon(xPoints,yPoints,nPoints);
|
|
}
|
|
|
|
public void drawPolygon(Polygon p)
|
|
{
|
|
graphics.drawPolygon(p);
|
|
backBufferGraphics.drawPolygon(p);
|
|
}
|
|
|
|
public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints)
|
|
{
|
|
graphics.drawPolyline(xPoints,yPoints,nPoints);
|
|
backBufferGraphics.drawPolyline(xPoints,yPoints,nPoints);
|
|
}
|
|
|
|
public void drawRect(int x, int y, int width, int height)
|
|
{
|
|
graphics.drawRect(x,y,width,height);
|
|
backBufferGraphics.drawRect(x,y,width,height);
|
|
}
|
|
|
|
public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
|
|
{
|
|
graphics.drawRoundRect(x,y,width,height,arcWidth,arcHeight);
|
|
backBufferGraphics.drawRoundRect(x,y,width,height,arcWidth,arcHeight);
|
|
}
|
|
|
|
public void drawString(AttributedCharacterIterator iterator, int x, int y)
|
|
{
|
|
graphics.drawString(iterator,x,y);
|
|
backBufferGraphics.drawString(iterator,x,y);
|
|
}
|
|
|
|
public void drawString(String str, int x, int y)
|
|
{
|
|
graphics.drawString(str,x,y);
|
|
backBufferGraphics.drawString(str,x,y);
|
|
}
|
|
|
|
public void fill3DRect(int x, int y, int width, int height, boolean raised)
|
|
{
|
|
graphics.fill3DRect(x,y,width,height,raised);
|
|
backBufferGraphics.fill3DRect(x,y,width,height,raised);
|
|
}
|
|
|
|
public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)
|
|
{
|
|
graphics.fillArc(x,y,width,height,startAngle,arcAngle);
|
|
backBufferGraphics.fillArc(x,y,width,height,startAngle,arcAngle);
|
|
}
|
|
|
|
public void fillOval(int x, int y, int width, int height)
|
|
{
|
|
graphics.fillOval(x,y,width,height);
|
|
backBufferGraphics.fillOval(x,y,width,height);
|
|
}
|
|
|
|
public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints)
|
|
{
|
|
graphics.fillPolygon(xPoints,yPoints,nPoints);
|
|
backBufferGraphics.fillPolygon(xPoints,yPoints,nPoints);
|
|
}
|
|
|
|
public void fillPolygon(Polygon p)
|
|
{
|
|
graphics.fillPolygon(p);
|
|
backBufferGraphics.fillPolygon(p);
|
|
}
|
|
|
|
public void fillRect(int x, int y, int width, int height)
|
|
{
|
|
graphics.fillRect(x,y,width,height);
|
|
backBufferGraphics.fillRect(x,y,width,height);
|
|
}
|
|
|
|
public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
|
|
{
|
|
graphics.fillRoundRect(x,y,width,height,arcWidth,arcHeight);
|
|
backBufferGraphics.fillRoundRect(x,y,width,height,arcWidth,arcHeight);
|
|
}
|
|
|
|
public Shape getClip()
|
|
{
|
|
return graphics.getClip();
|
|
}
|
|
|
|
public Rectangle getClipBounds()
|
|
{
|
|
return graphics.getClipBounds();
|
|
}
|
|
|
|
public Rectangle getClipBounds(Rectangle r)
|
|
{
|
|
return graphics.getClipBounds(r);
|
|
}
|
|
|
|
public Rectangle getClipRect()
|
|
{
|
|
return graphics.getClipRect();
|
|
}
|
|
|
|
public Color getColor()
|
|
{
|
|
return getColor();
|
|
}
|
|
|
|
public Font getFont()
|
|
{
|
|
return getFont();
|
|
}
|
|
|
|
public FontMetrics getFontMetrics()
|
|
{
|
|
return getFontMetrics();
|
|
}
|
|
|
|
public FontMetrics getFontMetrics(Font f)
|
|
{
|
|
return getFontMetrics(f);
|
|
}
|
|
|
|
public boolean hitClip(int x, int y, int width, int height)
|
|
{
|
|
return graphics.hitClip(x,y,width,height);
|
|
}
|
|
|
|
public void setClip(int x, int y, int width, int height)
|
|
{
|
|
graphics.setClip(x,y,width,height);
|
|
backBufferGraphics.setClip(x,y,width,height);
|
|
}
|
|
|
|
public void setClip(Shape clip)
|
|
{
|
|
graphics.setClip(clip);
|
|
backBufferGraphics.setClip(clip);
|
|
}
|
|
|
|
public void setColor(Color c)
|
|
{
|
|
graphics.setColor(c);
|
|
backBufferGraphics.setColor(c);
|
|
}
|
|
|
|
public void setFont(Font font)
|
|
{
|
|
graphics.setFont(font);
|
|
backBufferGraphics.setFont(font);
|
|
}
|
|
|
|
public void setPaintMode()
|
|
{
|
|
graphics.setPaintMode();
|
|
backBufferGraphics.setPaintMode();
|
|
}
|
|
|
|
public void setXORMode(Color c1)
|
|
{
|
|
graphics.setXORMode(c1);
|
|
backBufferGraphics.setXORMode(c1);
|
|
}
|
|
|
|
public String toString()
|
|
{
|
|
return graphics.toString();
|
|
}
|
|
|
|
public void translate(int x, int y)
|
|
{
|
|
graphics.translate(x,y);
|
|
backBufferGraphics.translate(x,y);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
//
|
|
// Graphics2D
|
|
// ==========
|
|
//
|
|
public void addRenderingHints(Map hints)
|
|
{
|
|
graphics.addRenderingHints(hints);
|
|
backBufferGraphics.addRenderingHints(hints);
|
|
}
|
|
|
|
public void clip(Shape s)
|
|
{
|
|
graphics.clip(s);
|
|
backBufferGraphics.clip(s);
|
|
}
|
|
|
|
public void draw(Shape s)
|
|
{
|
|
graphics.draw(s);
|
|
backBufferGraphics.draw(s);
|
|
}
|
|
|
|
public void drawGlyphVector(GlyphVector g, float x, float y)
|
|
{
|
|
graphics.drawGlyphVector(g,x,y);
|
|
backBufferGraphics.drawGlyphVector(g,x,y);
|
|
}
|
|
|
|
public void drawImage(BufferedImage img, BufferedImageOp op, int x, int y)
|
|
{
|
|
graphics.drawImage(img,op,x,y);
|
|
backBufferGraphics.drawImage(img,op,x,y);
|
|
}
|
|
|
|
public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs)
|
|
{
|
|
backBufferGraphics.drawImage(img,xform,obs);
|
|
return graphics.drawImage(img,xform,obs);
|
|
}
|
|
|
|
public void drawRenderableImage(RenderableImage img, AffineTransform xform)
|
|
{
|
|
graphics.drawRenderableImage(img,xform);
|
|
backBufferGraphics.drawRenderableImage(img,xform);
|
|
}
|
|
|
|
public void drawRenderedImage(RenderedImage img, AffineTransform xform)
|
|
{
|
|
graphics.drawRenderedImage(img,xform);
|
|
backBufferGraphics.drawRenderedImage(img,xform);
|
|
}
|
|
|
|
public void drawString(AttributedCharacterIterator iterator, float x, float y)
|
|
{
|
|
graphics.drawString(iterator,x,y);
|
|
backBufferGraphics.drawString(iterator,x,y);
|
|
}
|
|
|
|
public void drawString(String s, float x, float y)
|
|
{
|
|
graphics.drawString(s,x,y);
|
|
backBufferGraphics.drawString(s,x,y);
|
|
}
|
|
|
|
public void fill(Shape s)
|
|
{
|
|
graphics.fill(s);
|
|
backBufferGraphics.fill(s);
|
|
}
|
|
|
|
public Color getBackground()
|
|
{
|
|
return graphics.getBackground();
|
|
}
|
|
|
|
public Composite getComposite()
|
|
{
|
|
return graphics.getComposite();
|
|
}
|
|
|
|
public GraphicsConfiguration getDeviceConfiguration()
|
|
{
|
|
return graphics.getDeviceConfiguration();
|
|
}
|
|
|
|
public FontRenderContext getFontRenderContext()
|
|
{
|
|
return graphics.getFontRenderContext();
|
|
}
|
|
|
|
public Paint getPaint()
|
|
{
|
|
return graphics.getPaint();
|
|
}
|
|
|
|
public Object getRenderingHint(RenderingHints.Key hintKey)
|
|
{
|
|
return graphics.getRenderingHint(hintKey);
|
|
}
|
|
|
|
public RenderingHints getRenderingHints()
|
|
{
|
|
return graphics.getRenderingHints();
|
|
}
|
|
|
|
public Stroke getStroke()
|
|
{
|
|
return graphics.getStroke();
|
|
}
|
|
|
|
public AffineTransform getTransform()
|
|
{
|
|
return graphics.getTransform();
|
|
}
|
|
|
|
public boolean hit(Rectangle rect, Shape s, boolean onStroke)
|
|
{
|
|
return graphics.hit(rect,s,onStroke);
|
|
}
|
|
|
|
public void rotate(double theta)
|
|
{
|
|
graphics.rotate(theta);
|
|
backBufferGraphics.rotate(theta);
|
|
}
|
|
|
|
public void rotate(double theta, double x, double y)
|
|
{
|
|
graphics.rotate(theta,x,y);
|
|
backBufferGraphics.rotate(theta,x,y);
|
|
}
|
|
|
|
public void scale(double sx, double sy)
|
|
{
|
|
graphics.scale(sx,sy);
|
|
backBufferGraphics.scale(sx,sy);
|
|
}
|
|
|
|
public void setBackground(Color color)
|
|
{
|
|
graphics.setBackground(color);
|
|
backBufferGraphics.setBackground(color);
|
|
}
|
|
|
|
public void setComposite(Composite comp)
|
|
{
|
|
graphics.setComposite(comp);
|
|
backBufferGraphics.setComposite(comp);
|
|
}
|
|
|
|
public void setPaint(Paint paint)
|
|
{
|
|
graphics.setPaint(paint);
|
|
backBufferGraphics.setPaint(paint);
|
|
}
|
|
|
|
public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue)
|
|
{
|
|
graphics.setRenderingHint(hintKey,hintValue);
|
|
backBufferGraphics.setRenderingHint(hintKey,hintValue);
|
|
}
|
|
|
|
public void setRenderingHints(Map hints)
|
|
{
|
|
graphics.setRenderingHints(hints);
|
|
backBufferGraphics.setRenderingHints(hints);
|
|
}
|
|
|
|
public void setStroke(Stroke s)
|
|
{
|
|
graphics.setStroke(s);
|
|
backBufferGraphics.setStroke(s);
|
|
}
|
|
|
|
public void setTransform(AffineTransform Tx)
|
|
{
|
|
graphics.setTransform(Tx);
|
|
backBufferGraphics.setTransform(Tx);
|
|
}
|
|
|
|
public void shear(double shx, double shy)
|
|
{
|
|
graphics.shear(shx,shy);
|
|
backBufferGraphics.shear(shx,shy);
|
|
}
|
|
|
|
public void transform(AffineTransform Tx)
|
|
{
|
|
graphics.transform(Tx);
|
|
backBufferGraphics.transform(Tx);
|
|
}
|
|
|
|
public void translate(double tx, double ty)
|
|
{
|
|
graphics.translate(tx,ty);
|
|
backBufferGraphics.translate(tx,ty);
|
|
}
|
|
}
|