#110496# Merge from cws_srx645_canvas01: first working version of XCanvas UNO components, for now consisting of javacanvas.uno.jar, vclcanvas.uno and directxcanvas.uno (windows only)

1 files changed, 630 insertions, 0 deletions

diff --git a/canvas/source/java/BufferedGraphics2D.java b/canvas/source/java/BufferedGraphics2D.java
new file mode 100644
index 000000000000..53c89990b11e
--- /dev/null
+++ b/canvas/source/java/BufferedGraphics2D.java
@@ -0,0 +1,630 @@
+/*************************************************************************
+ *
+ *  $RCSfile: BufferedGraphics2D.java,v $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+0 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+// 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);
+    }
+}