canvas/source/java/BufferedGraphics2D.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: BufferedGraphics2D.java,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // Java AWT
  32 import java.awt.*;
  33 import java.awt.geom.*;
  34 import java.awt.image.*;
  35 import java.awt.image.renderable.*;
  36 import java.awt.font.*;
  37 import java.text.*;
  38 import java.util.*;
  39
  40
  41 public class BufferedGraphics2D
  42     extends java.awt.Graphics2D
  43 {
  44     // TODO: Somehow, get rid of this duplicate graphics (the graphics member,
  45     // and this object itself, extending a Graphics2D)
  46     private Graphics2D                  graphics;
  47     private BufferedImage               backBuffer;
  48     private Graphics2D                  backBufferGraphics;
  49
  50     //----------------------------------------------------------------------------------
  51
  52     public BufferedGraphics2D( java.awt.Graphics2D _graphics, int width, int height )
  53     {
  54         setGraphics( _graphics, Math.max(1,width), Math.max(1,height) );
  55     }
  56
  57     public void redraw( Graphics2D graph )
  58     {
  59         if( graph != null &&
  60             backBuffer != null )
  61         {
  62             CanvasUtils.printLog("BufferedGraphics2D.redraw: using buffer of size (" +
  63                                  backBuffer.getWidth() + "," + backBuffer.getHeight() + ")" );
  64
  65             // set transform to identity
  66             graph.setTransform( new AffineTransform() );
  67             graph.drawImage(backBuffer, 0, 0, null);
  68             CanvasUtils.postRenderImageTreatment( backBuffer );
  69         }
  70     }
  71
  72     public BufferedImage getBackBuffer()
  73     {
  74         return backBuffer;
  75     }
  76
  77     public void setSize( int width, int height )
  78     {
  79         if( backBuffer != null &&
  80             width == backBuffer.getWidth() &&
  81             height == backBuffer.getHeight() )
  82         {
  83             return;
  84         }
  85
  86         if( backBufferGraphics != null )
  87             backBufferGraphics.dispose();
  88
  89         if( backBuffer != null )
  90             backBuffer.flush();
  91
  92         // TODO: Maybe VolatileImage with another BufferedImage as a backup is
  93         // a tad faster here.
  94         backBuffer = graphics.getDeviceConfiguration().createCompatibleImage(width,
  95                                                                              height);
  96
  97         backBufferGraphics = backBuffer.createGraphics();
  98         CanvasUtils.initGraphics( backBufferGraphics );
  99
 100         // clear the buffer to white (to have a defined state here)
 101         backBufferGraphics.setColor( java.awt.Color.white );
 102         backBufferGraphics.fillRect( 0,0,width,height );
 103     }
 104
 105     public void setGraphics( Graphics2D _graphics, int width, int height )
 106     {
 107         if( graphics != null )
 108             graphics.dispose();
 109
 110         graphics = _graphics;
 111
 112         setSize(width,height);
 113     }
 114
 115     //----------------------------------------------------------------------------------
 116
 117     //
 118     // Graphics
 119     // ========
 120     //
 121     public void clearRect(int x, int y,  int width, int height)
 122     {
 123         graphics.clearRect(x,y,width,height);
 124         backBufferGraphics.clearRect(x,y,width,height);
 125     }
 126
 127     public void clipRect(int x, int y, int width, int height)
 128     {
 129         graphics.clipRect(x,y,width,height);
 130         backBufferGraphics.clipRect(x,y,width,height);
 131     }
 132
 133     public void copyArea(int x, int y, int width, int height, int dx, int dy)
 134     {
 135         graphics.copyArea(x,y,width,height,dx,dy);
 136         backBufferGraphics.copyArea(x,y,width,height,dx,dy);
 137     }
 138
 139     public Graphics create()
 140     {
 141         return null;
 142     }
 143
 144     public Graphics create(int x, int y, int width, int height)
 145     {
 146         return null;
 147     }
 148
 149     public void dispose()
 150     {
 151         graphics.dispose();
 152         backBufferGraphics.dispose();
 153         backBuffer.flush();
 154     }
 155
 156     public void draw3DRect(int x, int y, int width, int height, boolean raised)
 157     {
 158         graphics.draw3DRect(x,y,width,height,raised);
 159         backBufferGraphics.draw3DRect(x,y,width,height,raised);
 160     }
 161
 162     public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
 163     {
 164         graphics.drawArc(x,y,width,height,startAngle,arcAngle);
 165         backBufferGraphics.drawArc(x,y,width,height,startAngle,arcAngle);
 166     }
 167
 168     public void drawBytes(byte[] data, int offset, int length, int x, int y)
 169     {
 170         graphics.drawBytes(data,offset,length,x,y);
 171         backBufferGraphics.drawBytes(data,offset,length,x,y);
 172     }
 173
 174     public void drawChars(char[] data, int offset, int length, int x, int y)
 175     {
 176         graphics.drawChars(data,offset,length,x,y);
 177         backBufferGraphics.drawChars(data,offset,length,x,y);
 178     }
 179
 180     public boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer)
 181     {
 182         backBufferGraphics.drawImage(img,x,y,bgcolor,observer);
 183         return graphics.drawImage(img,x,y,bgcolor,observer);
 184     }
 185
 186     public boolean drawImage(Image img, int x, int y, ImageObserver observer)
 187     {
 188         backBufferGraphics.drawImage(img,x,y,observer);
 189         return graphics.drawImage(img,x,y,observer);
 190     }
 191
 192     public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor,  ImageObserver observer)
 193     {
 194         backBufferGraphics.drawImage(img,x,y,width,height,bgcolor,observer);
 195         return graphics.drawImage(img,x,y,width,height,bgcolor,observer);
 196     }
 197
 198     public boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)
 199     {
 200         backBufferGraphics.drawImage(img,x,y,width,height,observer);
 201         return graphics.drawImage(img,x,y,width,height,observer);
 202     }
 203
 204     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)
 205     {
 206         backBufferGraphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,bgcolor,observer);
 207         return graphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,bgcolor,observer);
 208     }
 209
 210     public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer)
 211     {
 212         backBufferGraphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,observer);
 213         return graphics.drawImage(img,dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2,observer);
 214     }
 215
 216     public void drawLine(int x1, int y1, int x2, int y2)
 217     {
 218         graphics.drawLine(x1,y1,x2,y2);
 219         backBufferGraphics.drawLine(x1,y1,x2,y2);
 220     }
 221
 222     public void drawOval(int x, int y, int width, int height)
 223     {
 224         graphics.drawOval(x,y,width,height);
 225         backBufferGraphics.drawOval(x,y,width,height);
 226     }
 227
 228     public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints)
 229     {
 230         graphics.drawPolygon(xPoints,yPoints,nPoints);
 231         backBufferGraphics.drawPolygon(xPoints,yPoints,nPoints);
 232     }
 233
 234     public void drawPolygon(Polygon p)
 235     {
 236         graphics.drawPolygon(p);
 237         backBufferGraphics.drawPolygon(p);
 238     }
 239
 240     public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints)
 241     {
 242         graphics.drawPolyline(xPoints,yPoints,nPoints);
 243         backBufferGraphics.drawPolyline(xPoints,yPoints,nPoints);
 244     }
 245
 246     public void drawRect(int x, int y, int width, int height)
 247     {
 248         graphics.drawRect(x,y,width,height);
 249         backBufferGraphics.drawRect(x,y,width,height);
 250     }
 251
 252     public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
 253     {
 254         graphics.drawRoundRect(x,y,width,height,arcWidth,arcHeight);
 255         backBufferGraphics.drawRoundRect(x,y,width,height,arcWidth,arcHeight);
 256     }
 257
 258     public void drawString(AttributedCharacterIterator iterator, int x, int y)
 259     {
 260         graphics.drawString(iterator,x,y);
 261         backBufferGraphics.drawString(iterator,x,y);
 262     }
 263
 264     public void drawString(String str, int x, int y)
 265     {
 266         graphics.drawString(str,x,y);
 267         backBufferGraphics.drawString(str,x,y);
 268     }
 269
 270     public void fill3DRect(int x, int y, int width, int height, boolean raised)
 271     {
 272         graphics.fill3DRect(x,y,width,height,raised);
 273         backBufferGraphics.fill3DRect(x,y,width,height,raised);
 274     }
 275
 276     public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)
 277     {
 278         graphics.fillArc(x,y,width,height,startAngle,arcAngle);
 279         backBufferGraphics.fillArc(x,y,width,height,startAngle,arcAngle);
 280     }
 281
 282     public void fillOval(int x, int y, int width, int height)
 283     {
 284         graphics.fillOval(x,y,width,height);
 285         backBufferGraphics.fillOval(x,y,width,height);
 286     }
 287
 288     public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints)
 289     {
 290         graphics.fillPolygon(xPoints,yPoints,nPoints);
 291         backBufferGraphics.fillPolygon(xPoints,yPoints,nPoints);
 292     }
 293
 294     public void fillPolygon(Polygon p)
 295     {
 296         graphics.fillPolygon(p);
 297         backBufferGraphics.fillPolygon(p);
 298     }
 299
 300     public void fillRect(int x, int y, int width, int height)
 301     {
 302         graphics.fillRect(x,y,width,height);
 303         backBufferGraphics.fillRect(x,y,width,height);
 304     }
 305
 306     public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
 307     {
 308         graphics.fillRoundRect(x,y,width,height,arcWidth,arcHeight);
 309         backBufferGraphics.fillRoundRect(x,y,width,height,arcWidth,arcHeight);
 310     }
 311
 312     public Shape getClip()
 313     {
 314         return graphics.getClip();
 315     }
 316
 317     public Rectangle getClipBounds()
 318     {
 319         return graphics.getClipBounds();
 320     }
 321
 322     public Rectangle getClipBounds(Rectangle r)
 323     {
 324         return graphics.getClipBounds(r);
 325     }
 326
 327     public Rectangle getClipRect()
 328     {
 329         return graphics.getClipRect();
 330     }
 331
 332     public Color getColor()
 333     {
 334         return getColor();
 335     }
 336
 337     public Font getFont()
 338     {
 339         return getFont();
 340     }
 341
 342     public FontMetrics getFontMetrics()
 343     {
 344         return getFontMetrics();
 345     }
 346
 347     public FontMetrics getFontMetrics(Font f)
 348     {
 349         return getFontMetrics(f);
 350     }
 351
 352     public boolean hitClip(int x, int y, int width, int height)
 353     {
 354         return graphics.hitClip(x,y,width,height);
 355     }
 356
 357     public void setClip(int x, int y, int width, int height)
 358     {
 359         graphics.setClip(x,y,width,height);
 360         backBufferGraphics.setClip(x,y,width,height);
 361     }
 362
 363     public void setClip(Shape clip)
 364     {
 365         graphics.setClip(clip);
 366         backBufferGraphics.setClip(clip);
 367     }
 368
 369     public void setColor(Color c)
 370     {
 371         graphics.setColor(c);
 372         backBufferGraphics.setColor(c);
 373     }
 374
 375     public void setFont(Font font)
 376     {
 377         graphics.setFont(font);
 378         backBufferGraphics.setFont(font);
 379     }
 380
 381     public void setPaintMode()
 382     {
 383         graphics.setPaintMode();
 384         backBufferGraphics.setPaintMode();
 385     }
 386
 387     public void setXORMode(Color c1)
 388     {
 389         graphics.setXORMode(c1);
 390         backBufferGraphics.setXORMode(c1);
 391     }
 392
 393     public String toString()
 394     {
 395         return graphics.toString();
 396     }
 397
 398     public void translate(int x, int y)
 399     {
 400         graphics.translate(x,y);
 401         backBufferGraphics.translate(x,y);
 402     }
 403
 404     //----------------------------------------------------------------------------------
 405
 406     //
 407     // Graphics2D
 408     // ==========
 409     //
 410     public void addRenderingHints(Map hints)
 411     {
 412         graphics.addRenderingHints(hints);
 413         backBufferGraphics.addRenderingHints(hints);
 414     }
 415
 416     public void clip(Shape s)
 417     {
 418         graphics.clip(s);
 419         backBufferGraphics.clip(s);
 420     }
 421
 422     public void draw(Shape s)
 423     {
 424         graphics.draw(s);
 425         backBufferGraphics.draw(s);
 426     }
 427
 428     public void drawGlyphVector(GlyphVector g, float x, float y)
 429     {
 430         graphics.drawGlyphVector(g,x,y);
 431         backBufferGraphics.drawGlyphVector(g,x,y);
 432     }
 433
 434     public void drawImage(BufferedImage img, BufferedImageOp op, int x, int y)
 435     {
 436         graphics.drawImage(img,op,x,y);
 437         backBufferGraphics.drawImage(img,op,x,y);
 438     }
 439
 440     public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs)
 441     {
 442         backBufferGraphics.drawImage(img,xform,obs);
 443         return graphics.drawImage(img,xform,obs);
 444     }
 445
 446     public void drawRenderableImage(RenderableImage img, AffineTransform xform)
 447     {
 448         graphics.drawRenderableImage(img,xform);
 449         backBufferGraphics.drawRenderableImage(img,xform);
 450     }
 451
 452     public void drawRenderedImage(RenderedImage img, AffineTransform xform)
 453     {
 454         graphics.drawRenderedImage(img,xform);
 455         backBufferGraphics.drawRenderedImage(img,xform);
 456     }
 457
 458     public void drawString(AttributedCharacterIterator iterator, float x, float y)
 459     {
 460         graphics.drawString(iterator,x,y);
 461         backBufferGraphics.drawString(iterator,x,y);
 462     }
 463
 464     public void drawString(String s, float x, float y)
 465     {
 466         graphics.drawString(s,x,y);
 467         backBufferGraphics.drawString(s,x,y);
 468     }
 469
 470     public void fill(Shape s)
 471     {
 472         graphics.fill(s);
 473         backBufferGraphics.fill(s);
 474     }
 475
 476     public Color getBackground()
 477     {
 478         return graphics.getBackground();
 479     }
 480
 481     public Composite getComposite()
 482     {
 483         return graphics.getComposite();
 484     }
 485
 486     public GraphicsConfiguration getDeviceConfiguration()
 487     {
 488         return graphics.getDeviceConfiguration();
 489     }
 490
 491     public FontRenderContext getFontRenderContext()
 492     {
 493         return graphics.getFontRenderContext();
 494     }
 495
 496     public Paint getPaint()
 497     {
 498         return graphics.getPaint();
 499     }
 500
 501     public Object getRenderingHint(RenderingHints.Key hintKey)
 502     {
 503         return graphics.getRenderingHint(hintKey);
 504     }
 505
 506     public RenderingHints getRenderingHints()
 507     {
 508         return graphics.getRenderingHints();
 509     }
 510
 511     public Stroke getStroke()
 512     {
 513         return graphics.getStroke();
 514     }
 515
 516     public AffineTransform getTransform()
 517     {
 518         return graphics.getTransform();
 519     }
 520
 521     public boolean hit(Rectangle rect, Shape s, boolean onStroke)
 522     {
 523         return graphics.hit(rect,s,onStroke);
 524     }
 525
 526     public void rotate(double theta)
 527     {
 528         graphics.rotate(theta);
 529         backBufferGraphics.rotate(theta);
 530     }
 531
 532     public void rotate(double theta, double x, double y)
 533     {
 534         graphics.rotate(theta,x,y);
 535         backBufferGraphics.rotate(theta,x,y);
 536     }
 537
 538     public void scale(double sx, double sy)
 539     {
 540         graphics.scale(sx,sy);
 541         backBufferGraphics.scale(sx,sy);
 542     }
 543
 544     public void setBackground(Color color)
 545     {
 546         graphics.setBackground(color);
 547         backBufferGraphics.setBackground(color);
 548     }
 549
 550     public void setComposite(Composite comp)
 551     {
 552         graphics.setComposite(comp);
 553         backBufferGraphics.setComposite(comp);
 554     }
 555
 556     public void setPaint(Paint paint)
 557     {
 558         graphics.setPaint(paint);
 559         backBufferGraphics.setPaint(paint);
 560     }
 561
 562     public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue)
 563     {
 564         graphics.setRenderingHint(hintKey,hintValue);
 565         backBufferGraphics.setRenderingHint(hintKey,hintValue);
 566     }
 567
 568     public void setRenderingHints(Map hints)
 569     {
 570         graphics.setRenderingHints(hints);
 571         backBufferGraphics.setRenderingHints(hints);
 572     }
 573
 574     public void setStroke(Stroke s)
 575     {
 576         graphics.setStroke(s);
 577         backBufferGraphics.setStroke(s);
 578     }
 579
 580     public void setTransform(AffineTransform Tx)
 581     {
 582         graphics.setTransform(Tx);
 583         backBufferGraphics.setTransform(Tx);
 584     }
 585
 586     public void shear(double shx, double shy)
 587     {
 588         graphics.shear(shx,shy);
 589         backBufferGraphics.shear(shx,shy);
 590     }
 591
 592     public void transform(AffineTransform Tx)
 593     {
 594         graphics.transform(Tx);
 595         backBufferGraphics.transform(Tx);
 596     }
 597
 598     public void translate(double tx, double ty)
 599     {
 600         graphics.translate(tx,ty);
 601         backBufferGraphics.translate(tx,ty);
 602     }
 603 }