bundles/org.eclipse.rap.rwt/src/org/eclipse/swt/graphics/GC.java - rap/org.eclipse.rap - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 Innoopract Informationssysteme GmbH.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Innoopract Informationssysteme GmbH - initial API and implementation
  ******************************************************************************/
 package org.eclipse.swt.graphics;

 import java.awt.*;
 import java.awt.geom.Line2D;
 import java.awt.image.BufferedImage;
 import java.io.*;
 import java.util.Iterator;

 import javax.imageio.ImageIO;
 import javax.imageio.ImageWriter;
 import javax.imageio.stream.ImageOutputStream;

 import org.eclipse.rwt.internal.ConfigurationReader;
 import org.eclipse.rwt.internal.IEngineConfig;
 import org.eclipse.rwt.internal.resources.ResourceManager;
 import org.eclipse.rwt.resources.IResourceManager;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.internal.graphics.ResourceFactory;
 import org.eclipse.swt.widgets.Display;

 // RAP [bm]: e4-enabling hacks
 public class GC extends Resource {

   private static final String IMAGE_FORMAT = "jpeg";
   private final int style;
   private Image image;
   private BufferedImage bufferedImage;
   private Graphics2D graphics;
   private Stroke lineStroke;
   private Color background;
   private Color foreground;
   private float lineWidth;
   private int lineCap;
   private int lineJoin;
   private int lineStyle;
   private float[] lineDashes;
   private float lineDashesOffset;
   private float lineMiterLimit;

   // TODO [rh] change ctor to GC(Image) and GC(Image,int)? would be less
   // compatible with SWT but show problems at compile time.
   public GC( final Drawable drawable ) {
     this( drawable, SWT.NONE );
   }

   public GC( final Drawable drawable, final int style ) {
     if( drawable == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     image = ( Image )drawable;
     this.style = checkStyle( style );
     this.bufferedImage = createBufferedImage( image );
     this.graphics = bufferedImage.createGraphics();
     initDefaults();
   }

   public int getStyle() {
     checkGC();
     return style;
   }

   // /////////////////
   // Attribute setter
   public void setBackground( final Color color ) {
     checkGC();
     if( color == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     background = color;
   }

   public Color getBackground() {
     checkGC();
     return background;
   }

   public void setForeground( final Color color ) {
     checkGC();
     if( color == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     foreground = color;
   }

   public Color getForeground() {
     checkGC();
     return foreground;
   }

   public void setAntialias( final int antialias ) {
     checkGC();
     Object hintValue = null;
     switch( antialias ) {
       case SWT.DEFAULT:
         hintValue = RenderingHints.VALUE_ANTIALIAS_DEFAULT;
       break;
       case SWT.OFF:
         hintValue = RenderingHints.VALUE_ANTIALIAS_OFF;
       break;
       case SWT.ON:
         hintValue = RenderingHints.VALUE_ANTIALIAS_ON;
       break;
       default:
         SWT.error( SWT.ERROR_INVALID_ARGUMENT );
     }
     graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, hintValue );
   }

   public int getAntialias() {
     checkGC();
     int result = SWT.DEFAULT;
     Object value = graphics.getRenderingHint( RenderingHints.KEY_ANTIALIASING );
     if( RenderingHints.VALUE_ANTIALIAS_DEFAULT.equals( value ) ) {
       result = SWT.DEFAULT;
     } else if( RenderingHints.VALUE_ANTIALIAS_OFF.equals( value ) ) {
       result = SWT.OFF;
     } else if( RenderingHints.VALUE_ANTIALIAS_ON.equals( value ) ) {
       result = SWT.ON;
     }
     return result;
   }

   // /////////////
   // Clip methods
   public void setClipping( final Rectangle rect ) {
     checkGC();
     if( rect == null ) {
       graphics.setClip( null );
     } else {
       setClipping( rect.x, rect.y, rect.width, rect.height );
     }
   }

   public void setClipping( final int x,
                            final int y,
                            final int width,
                            final int height )
   {
     checkGC();
     graphics.setClip( x, y, width, height );
   }

   public Rectangle getClipping() {
     checkGC();
     java.awt.Rectangle rect = graphics.getClipBounds();
     Rectangle result;
     if( rect == null ) {
       Rectangle bounds = image.getBounds();
       result = new Rectangle( bounds.x, bounds.y, bounds.width, bounds.height );
     } else {
       result = new Rectangle( rect.x, rect.y, rect.width, rect.height );
     }
     return result;
   }

   // //////////////
   // Fill methods
   public void fillRectangle( final Rectangle rect ) {
     if( rect == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     fillRectangle( rect.x, rect.y, rect.width, rect.height );
   }

   public void fillRectangle( final int x,
                              final int y,
                              final int width,
                              final int height )
   {
     checkGC();
     applyColor( background );
     graphics.fillRect( x, y, width - 1, height - 1 );
   }

   public void fillGradientRectangle( final int x,
                                      final int y,
                                      final int width,
                                      final int height,
                                      final boolean vertical )
   {
     java.awt.Color fromColor = toAWTColor( foreground );
     java.awt.Color toColor = toAWTColor( background );
     LinearGradientPaint gradientPaint = new LinearGradientPaint( x,
                                                                  y,
                                                                  x + width,
                                                                  y + height,
                                                                  new float[]{
                                                                    0.0f, 1.0f
                                                                  },
                                                                  new java.awt.Color[]{
                                                                    fromColor,
                                                                    toColor
                                                                  } );
     graphics.setPaint( gradientPaint );
     graphics.fill( new java.awt.Rectangle( x, y, width, height ) );
   }

   // ////////////////
   // Line attributes
   public void setLineWidth( final int lineWidth ) {
     checkGC();
     if( this.lineWidth != lineWidth ) {
       this.lineWidth = lineWidth;
       lineStroke = null;
     }
   }

   public int getLineWidth() {
     checkGC();
     return ( int )lineWidth;
   }

   public void setLineCap( final int lineCap ) {
     checkGC();
     if( this.lineCap != lineCap ) {
       switch( lineCap ) {
         case SWT.CAP_ROUND:
         case SWT.CAP_FLAT:
         case SWT.CAP_SQUARE:
         break;
         default:
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
       }
       this.lineCap = lineCap;
       lineStroke = null;
     }
   }

   public int getLineCap() {
     checkGC();
     return lineCap;
   }

   public void setLineJoin( final int lineJoin ) {
     checkGC();
     if( this.lineJoin != lineJoin ) {
       switch( lineJoin ) {
         case SWT.JOIN_MITER:
         case SWT.JOIN_ROUND:
         case SWT.JOIN_BEVEL:
         break;
         default:
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
       }
       this.lineJoin = lineJoin;
       lineStroke = null;
     }
   }

   public int getLineJoin() {
     checkGC();
     return lineJoin;
   }

   public void setLineStyle( final int lineStyle ) {
     checkGC();
     if( this.lineStyle != lineStyle ) {
       switch( lineStyle ) {
         case SWT.LINE_SOLID:
         case SWT.LINE_DASH:
         case SWT.LINE_DOT:
         case SWT.LINE_DASHDOT:
         case SWT.LINE_DASHDOTDOT:
         case SWT.LINE_CUSTOM:
         break;
         default:
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
       }
       if( lineStyle == SWT.LINE_CUSTOM && lineDashes == null ) {
         this.lineStyle = SWT.LINE_SOLID;
       } else {
         this.lineStyle = lineStyle;
       }
       lineStroke = null;
     }
   }

   public int getLineStyle() {
     checkGC();
     return lineStyle;
   }

   public void setLineDash( int[] dashes ) {
     checkGC();
     float[] lineDashes = this.lineDashes;
     if( dashes != null && dashes.length > 0 ) {
       boolean changed = this.lineStyle != SWT.LINE_CUSTOM
                         || lineDashes == null
                         || lineDashes.length != dashes.length;
       for( int i = 0; i < dashes.length; i++ ) {
         int dash = dashes[ i ];
         if( dash <= 0 ) {
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
         }
         if( !changed && lineDashes[ i ] != dash )
           changed = true;
       }
       if( changed ) {
         this.lineDashes = new float[ dashes.length ];
         for( int i = 0; i < dashes.length; i++ ) {
           this.lineDashes[ i ] = dashes[ i ];
         }
         this.lineStyle = SWT.LINE_CUSTOM;
         lineStroke = null;
       }
     } else {
       if( this.lineStyle != SWT.LINE_SOLID
           || ( lineDashes != null && lineDashes.length != 0 ) )
       {
         this.lineDashes = null;
         this.lineStyle = SWT.LINE_SOLID;
         lineStroke = null;
       }
     }
   }

   public int[] getLineDash() {
     checkGC();
     int[] result = null;
     if( lineDashes != null ) {
       result = new int[ lineDashes.length ];
       for( int i = 0; i < result.length; i++ ) {
         result[ i ] = ( int )lineDashes[ i ];
       }
     }
     return result;
   }

   public void setLineAttributes( final LineAttributes attributes ) {
     checkGC();
     if( attributes == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     boolean changed = false;
     float lineWidth = attributes.width;
     if( lineWidth != this.lineWidth ) {
       changed = true;
     }
     int lineStyle = attributes.style;
     if( lineStyle != this.lineStyle ) {
       changed = true;
       switch( lineStyle ) {
         case SWT.LINE_SOLID:
         case SWT.LINE_DASH:
         case SWT.LINE_DOT:
         case SWT.LINE_DASHDOT:
         case SWT.LINE_DASHDOTDOT:
         break;
         case SWT.LINE_CUSTOM:
           if( attributes.dash == null )
             lineStyle = SWT.LINE_SOLID;
         break;
         default:
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
       }
     }
     int join = attributes.join;
     if( join != this.lineJoin ) {
       changed = true;
       switch( join ) {
         case SWT.CAP_ROUND:
         case SWT.CAP_FLAT:
         case SWT.CAP_SQUARE:
         break;
         default:
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
       }
     }
     int cap = attributes.join;
     if( cap != this.lineCap ) {
       changed = true;
       switch( cap ) {
         case SWT.JOIN_MITER:
         case SWT.JOIN_ROUND:
         case SWT.JOIN_BEVEL:
         break;
         default:
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
       }
     }
     float[] dashes = attributes.dash;
     float[] lineDashes = this.lineDashes;
     if( dashes != null && dashes.length > 0 ) {
       boolean dashesChanged = lineDashes == null
                               || lineDashes.length != dashes.length;
       for( int i = 0; i < dashes.length; i++ ) {
         float dash = dashes[ i ];
         if( dash <= 0 )
           SWT.error( SWT.ERROR_INVALID_ARGUMENT );
         if( !dashesChanged && lineDashes[ i ] != dash )
           dashesChanged = true;
       }
       if( dashesChanged ) {
         float[] newDashes = new float[ dashes.length ];
         System.arraycopy( dashes, 0, newDashes, 0, dashes.length );
         dashes = newDashes;
         changed = true;
       } else {
         dashes = lineDashes;
       }
     } else {
       if( lineDashes != null && lineDashes.length > 0 ) {
         changed = true;
       } else {
         dashes = lineDashes;
       }
     }
     float dashOffset = attributes.dashOffset;
     if( dashOffset != this.lineDashesOffset ) {
       changed = true;
     }
     float miterLimit = attributes.miterLimit;
     if( miterLimit != this.lineMiterLimit ) {
       changed = true;
     }
     if( changed ) {
       this.lineWidth = lineWidth;
       this.lineStyle = lineStyle;
       this.lineCap = cap;
       this.lineJoin = join;
       this.lineDashes = dashes;
       this.lineDashesOffset = dashOffset;
       this.lineMiterLimit = miterLimit;
       lineStroke = null;
     }
   }

   public LineAttributes getLineAttributes() {
     checkGC();
     float[] dashes = null;
     if( lineDashes != null ) {
       dashes = new float[ lineDashes.length ];
       System.arraycopy( lineDashes, 0, dashes, 0, dashes.length );
     }
     return new LineAttributes( lineWidth,
                                lineCap,
                                lineJoin,
                                lineStyle,
                                dashes,
                                lineDashesOffset,
                                lineMiterLimit );
   }

   // ////////////////
   // Drawing methods
   public void drawLine( final int x1, final int y1, final int x2, final int y2 )
   {
     checkGC();
     applyColor( foreground );
     applyLineStroke();
     Line2D.Float line = new Line2D.Float( x1, y1, x2, y2 );
     graphics.draw( line );
   }

   public void drawRectangle( final Rectangle rect ) {
     if( rect == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     drawRectangle( rect.x, rect.y, rect.width, rect.height );
   }

   public void drawRectangle( final int x,
                              final int y,
                              final int width,
                              final int height )
   {
     checkGC();
     applyColor( foreground );
     graphics.drawRect( x, y, width - 1, height - 1 );
   }

   public void drawRoundRectangle( final int x,
                                   final int y,
                                   final int width,
                                   final int height,
                                   final int arcWidth,
                                   final int arcHeight )
   {
     checkGC();
     applyColor( foreground );
     graphics.drawRoundRect( x, y, width - 1, height - 1, arcWidth, arcHeight );
   }

   public void fillPolygon( int[] shapeArray ) {
     applyColor( background );
     graphics.fillPolygon( getPolygon( shapeArray ) );
   }

   public void drawPolygon( int[] shapeArray ) {
     applyColor( foreground );
     graphics.drawPolygon( getPolygon( shapeArray ) );
   }

   private Polygon getPolygon( int[] shapeArray ) {
     Polygon result = new Polygon();
     int numberOfPoints = shapeArray.length / 2;
     int[] xcoords = new int[ numberOfPoints ];
     int[] ycoords = new int[ numberOfPoints ];
     for( int i = 0; i <= numberOfPoints; i++ ) {
       xcoords[ i ] = shapeArray[ i ];
       xcoords[ i ] = shapeArray[ i + 1 ];
     }
     result.npoints = numberOfPoints;
     result.xpoints = xcoords;
     result.ypoints = ycoords;
     return result;
   }

   public void drawImage( final Image image, final int x, final int y ) {
     checkGC();
     if( image == null ) {
       SWT.error( SWT.ERROR_NULL_ARGUMENT );
     }
     BufferedImage awtImage = toAWTImage( image );
     graphics.drawImage( awtImage, x, y, null );
   }

   // ///////////////////////
   // dispose and isDisposed
   public void dispose() {
     writeImage();
     graphics.dispose();
     graphics = null;
     bufferedImage = null;
     image = null;
   }

   public boolean isDisposed() {
     return bufferedImage == null;
   }

   public String toString() {
     String result;
     if( isDisposed() ) {
       result = "GC {*DISPOSED*}";
     } else {
       result = "GC {" + bufferedImage + "}";
     }
     return result;
   }

   // ///////////////////////////////
   // Helping methods to write image
   private void writeImage() {
     ImageWriter writer = getImageWriter();
     File location = getImageResourceLocation( image );
     try {
       ImageOutputStream stream = ImageIO.createImageOutputStream( location );
       try {
         writer.setOutput( stream );
         writer.write( bufferedImage );
       } finally {
         stream.close();
       }
     } catch( IOException e ) {
       SWT.error( SWT.ERROR_IO, e );
     } finally {
       writer.dispose();
     }
   }

   private static ImageWriter getImageWriter() {
     ImageWriter result = null;
     Iterator imageWriters = ImageIO.getImageWritersByFormatName( IMAGE_FORMAT );
     if( imageWriters.hasNext() ) {
       result = ( ImageWriter )imageWriters.next();
     }
     if( result == null ) {
       SWT.error( SWT.ERROR_UNSUPPORTED_FORMAT, null, IMAGE_FORMAT );
     }
     return result;
   }

   private static File getImageResourceLocation( final Image image ) {
     IEngineConfig engineConfig = ConfigurationReader.getEngineConfig();
     File serverContextDir = engineConfig.getServerContextDir();
     String filename = "gen_" + image.hashCode();
     ResourceFactory.images.put( filename, image );
     return new File( serverContextDir, filename );
   }

   // /////////////////////////////
   // AWT Graphics Helping Methods
   private void applyColor( final Color color ) {
     graphics.setColor( toAWTColor( color ) );
   }

   private void applyLineStroke() {
     if( lineStroke == null ) {
       int awtLineCap = -1;
       switch( lineCap ) {
         case SWT.CAP_FLAT:
           awtLineCap = BasicStroke.CAP_BUTT;
         break;
         case SWT.CAP_ROUND:
           awtLineCap = BasicStroke.CAP_ROUND;
         break;
         case SWT.CAP_SQUARE:
           awtLineCap = BasicStroke.CAP_SQUARE;
         break;
       }
       int awtLineJoin = -1;
       switch( lineJoin ) {
         case SWT.JOIN_BEVEL:
           awtLineJoin = BasicStroke.JOIN_BEVEL;
         break;
         case SWT.JOIN_ROUND:
           awtLineJoin = BasicStroke.JOIN_ROUND;
         break;
         case SWT.JOIN_MITER:
           awtLineJoin = BasicStroke.JOIN_MITER;
         break;
       }
       float[] awtDashes = null;
       switch( lineStyle ) {
         case SWT.LINE_SOLID:
         break;
         case SWT.LINE_DASH:
           new UnsupportedOperationException( "dashes not yet implemented" );
         break;
         case SWT.LINE_DASHDOT:
           new UnsupportedOperationException( "dashes not yet implemented" );
         break;
         case SWT.LINE_DASHDOTDOT:
           new UnsupportedOperationException( "dashes not yet implemented" );
         break;
         case SWT.LINE_DOT:
           new UnsupportedOperationException( "dashes not yet implemented" );
         break;
         case SWT.LINE_CUSTOM:
           awtDashes = new float[ lineDashes.length ];
           for( int i = 0; i < lineDashes.length; i++ ) {
             awtDashes[ i ] = lineDashes[ i ];
           }
         break;
       }
       lineStroke = new BasicStroke( lineWidth,
                                     awtLineCap,
                                     awtLineJoin,
                                     lineMiterLimit,
                                     awtDashes,
                                     lineDashesOffset );
       graphics.setStroke( lineStroke );
     }
   }

   // //////////////////////
   // SWT to AWT conversion
   private static java.awt.Color toAWTColor( final Color color ) {
     return new java.awt.Color( color.getRed(),
                                color.getGreen(),
                                color.getBlue() );
   }

   private BufferedImage toAWTImage( final Image image ) {
     BufferedImage result = null;
     IResourceManager manager = ResourceManager.getInstance();
     String imagePath = ResourceFactory.getImagePath( image );
     try {
       InputStream inputStream = manager.getRegisteredContent( imagePath );
       try {
         boolean saveUseCache = ImageIO.getUseCache();
         ImageIO.setUseCache( false );
         try {
           result = ImageIO.read( inputStream );
         } finally {
           ImageIO.setUseCache( saveUseCache );
         }
       } finally {
         inputStream.close();
       }
     } catch( IOException e ) {
       String msg = "Failed to read input stream of image: " + imagePath;
       SWT.error( SWT.ERROR_IO, e, msg );
     }
     return result;
   }

   // ////////////////
   // Helping methods
   private void initDefaults() {
     // white background
     background = org.eclipse.rwt.graphics.Graphics.getColor( 255, 255, 255 );
     // black foreground
     foreground = org.eclipse.rwt.graphics.Graphics.getColor( 0, 0, 0 );
     // line attributes
     lineWidth = 0;
     lineCap = SWT.CAP_FLAT;
     lineJoin = SWT.JOIN_MITER;
     lineStyle = SWT.LINE_SOLID;
     lineDashes = null;
     lineDashesOffset = 0;
     lineMiterLimit = 10;
     // fill with default GC bg as the default Graphics bg is different
     Rectangle bounds = image.getBounds();
     applyColor( background );
     graphics.fillRect( 0, 0, bounds.width, image.getBounds().height );
     // set antialias to default
     graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING,
                                RenderingHints.VALUE_ANTIALIAS_DEFAULT );
   }

   private void checkGC() {
     if( bufferedImage == null ) {
       SWT.error( SWT.ERROR_GRAPHIC_DISPOSED );
     }
   }

   private static BufferedImage createBufferedImage( final Image image ) {
     Rectangle bounds = image.getBounds();
     int type = BufferedImage.TYPE_INT_RGB;
     return new BufferedImage( bounds.width, bounds.height, type );
   }

   private static int checkStyle( final int style ) {
     // if ((style & SWT.LEFT_TO_RIGHT) != 0) style &= ~SWT.RIGHT_TO_LEFT;
     // return style & (SWT.LEFT_TO_RIGHT | SWT.RIGHT_TO_LEFT);
     return style;
   }

   public Device getDevice() {
     return Display.getCurrent();
   }

   public void fillRoundRectangle( int x,
                                   int y,
                                   int width,
                                   int height,
                                   int arcWidth,
                                   int arcHeight )
   {
     checkGC();
     applyColor( background );
     graphics.fillRoundRect( x, y, width, height, arcWidth, arcHeight );
   }
 }
	/*******************************************************************************
	* Copyright (c) 2009 Innoopract Informationssysteme GmbH.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Innoopract Informationssysteme GmbH - initial API and implementation
	******************************************************************************/
	package org.eclipse.swt.graphics;

	import java.awt.*;
	import java.awt.geom.Line2D;
	import java.awt.image.BufferedImage;
	import java.io.*;
	import java.util.Iterator;

	import javax.imageio.ImageIO;
	import javax.imageio.ImageWriter;
	import javax.imageio.stream.ImageOutputStream;

	import org.eclipse.rwt.internal.ConfigurationReader;
	import org.eclipse.rwt.internal.IEngineConfig;
	import org.eclipse.rwt.internal.resources.ResourceManager;
	import org.eclipse.rwt.resources.IResourceManager;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.internal.graphics.ResourceFactory;
	import org.eclipse.swt.widgets.Display;

	// RAP [bm]: e4-enabling hacks
	public class GC extends Resource {

	private static final String IMAGE_FORMAT = "jpeg";
	private final int style;
	private Image image;
	private BufferedImage bufferedImage;
	private Graphics2D graphics;
	private Stroke lineStroke;
	private Color background;
	private Color foreground;
	private float lineWidth;
	private int lineCap;
	private int lineJoin;
	private int lineStyle;
	private float[] lineDashes;
	private float lineDashesOffset;
	private float lineMiterLimit;

	// TODO [rh] change ctor to GC(Image) and GC(Image,int)? would be less
	// compatible with SWT but show problems at compile time.
	public GC( final Drawable drawable ) {
	this( drawable, SWT.NONE );
	}

	public GC( final Drawable drawable, final int style ) {
	if( drawable == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	image = ( Image )drawable;
	this.style = checkStyle( style );
	this.bufferedImage = createBufferedImage( image );
	this.graphics = bufferedImage.createGraphics();
	initDefaults();
	}

	public int getStyle() {
	checkGC();
	return style;
	}

	// /////////////////
	// Attribute setter
	public void setBackground( final Color color ) {
	checkGC();
	if( color == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	background = color;
	}

	public Color getBackground() {
	checkGC();
	return background;
	}

	public void setForeground( final Color color ) {
	checkGC();
	if( color == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	foreground = color;
	}

	public Color getForeground() {
	checkGC();
	return foreground;
	}

	public void setAntialias( final int antialias ) {
	checkGC();
	Object hintValue = null;
	switch( antialias ) {
	case SWT.DEFAULT:
	hintValue = RenderingHints.VALUE_ANTIALIAS_DEFAULT;
	break;
	case SWT.OFF:
	hintValue = RenderingHints.VALUE_ANTIALIAS_OFF;
	break;
	case SWT.ON:
	hintValue = RenderingHints.VALUE_ANTIALIAS_ON;
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, hintValue );
	}

	public int getAntialias() {
	checkGC();
	int result = SWT.DEFAULT;
	Object value = graphics.getRenderingHint( RenderingHints.KEY_ANTIALIASING );
	if( RenderingHints.VALUE_ANTIALIAS_DEFAULT.equals( value ) ) {
	result = SWT.DEFAULT;
	} else if( RenderingHints.VALUE_ANTIALIAS_OFF.equals( value ) ) {
	result = SWT.OFF;
	} else if( RenderingHints.VALUE_ANTIALIAS_ON.equals( value ) ) {
	result = SWT.ON;
	}
	return result;
	}

	// /////////////
	// Clip methods
	public void setClipping( final Rectangle rect ) {
	checkGC();
	if( rect == null ) {
	graphics.setClip( null );
	} else {
	setClipping( rect.x, rect.y, rect.width, rect.height );
	}
	}

	public void setClipping( final int x,
	final int y,
	final int width,
	final int height )
	{
	checkGC();
	graphics.setClip( x, y, width, height );
	}

	public Rectangle getClipping() {
	checkGC();
	java.awt.Rectangle rect = graphics.getClipBounds();
	Rectangle result;
	if( rect == null ) {
	Rectangle bounds = image.getBounds();
	result = new Rectangle( bounds.x, bounds.y, bounds.width, bounds.height );
	} else {
	result = new Rectangle( rect.x, rect.y, rect.width, rect.height );
	}
	return result;
	}

	// //////////////
	// Fill methods
	public void fillRectangle( final Rectangle rect ) {
	if( rect == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	fillRectangle( rect.x, rect.y, rect.width, rect.height );
	}

	public void fillRectangle( final int x,
	final int y,
	final int width,
	final int height )
	{
	checkGC();
	applyColor( background );
	graphics.fillRect( x, y, width - 1, height - 1 );
	}

	public void fillGradientRectangle( final int x,
	final int y,
	final int width,
	final int height,
	final boolean vertical )
	{
	java.awt.Color fromColor = toAWTColor( foreground );
	java.awt.Color toColor = toAWTColor( background );
	LinearGradientPaint gradientPaint = new LinearGradientPaint( x,
	y,
	x + width,
	y + height,
	new float[]{
	0.0f, 1.0f
	},
	new java.awt.Color[]{
	fromColor,
	toColor
	} );
	graphics.setPaint( gradientPaint );
	graphics.fill( new java.awt.Rectangle( x, y, width, height ) );
	}

	// ////////////////
	// Line attributes
	public void setLineWidth( final int lineWidth ) {
	checkGC();
	if( this.lineWidth != lineWidth ) {
	this.lineWidth = lineWidth;
	lineStroke = null;
	}
	}

	public int getLineWidth() {
	checkGC();
	return ( int )lineWidth;
	}

	public void setLineCap( final int lineCap ) {
	checkGC();
	if( this.lineCap != lineCap ) {
	switch( lineCap ) {
	case SWT.CAP_ROUND:
	case SWT.CAP_FLAT:
	case SWT.CAP_SQUARE:
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	this.lineCap = lineCap;
	lineStroke = null;
	}
	}

	public int getLineCap() {
	checkGC();
	return lineCap;
	}

	public void setLineJoin( final int lineJoin ) {
	checkGC();
	if( this.lineJoin != lineJoin ) {
	switch( lineJoin ) {
	case SWT.JOIN_MITER:
	case SWT.JOIN_ROUND:
	case SWT.JOIN_BEVEL:
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	this.lineJoin = lineJoin;
	lineStroke = null;
	}
	}

	public int getLineJoin() {
	checkGC();
	return lineJoin;
	}

	public void setLineStyle( final int lineStyle ) {
	checkGC();
	if( this.lineStyle != lineStyle ) {
	switch( lineStyle ) {
	case SWT.LINE_SOLID:
	case SWT.LINE_DASH:
	case SWT.LINE_DOT:
	case SWT.LINE_DASHDOT:
	case SWT.LINE_DASHDOTDOT:
	case SWT.LINE_CUSTOM:
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	if( lineStyle == SWT.LINE_CUSTOM && lineDashes == null ) {
	this.lineStyle = SWT.LINE_SOLID;
	} else {
	this.lineStyle = lineStyle;
	}
	lineStroke = null;
	}
	}

	public int getLineStyle() {
	checkGC();
	return lineStyle;
	}

	public void setLineDash( int[] dashes ) {
	checkGC();
	float[] lineDashes = this.lineDashes;
	if( dashes != null && dashes.length > 0 ) {
	boolean changed = this.lineStyle != SWT.LINE_CUSTOM
	\|\| lineDashes == null
	\|\| lineDashes.length != dashes.length;
	for( int i = 0; i < dashes.length; i++ ) {
	int dash = dashes[ i ];
	if( dash <= 0 ) {
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	if( !changed && lineDashes[ i ] != dash )
	changed = true;
	}
	if( changed ) {
	this.lineDashes = new float[ dashes.length ];
	for( int i = 0; i < dashes.length; i++ ) {
	this.lineDashes[ i ] = dashes[ i ];
	}
	this.lineStyle = SWT.LINE_CUSTOM;
	lineStroke = null;
	}
	} else {
	if( this.lineStyle != SWT.LINE_SOLID
	\|\| ( lineDashes != null && lineDashes.length != 0 ) )
	{
	this.lineDashes = null;
	this.lineStyle = SWT.LINE_SOLID;
	lineStroke = null;
	}
	}
	}

	public int[] getLineDash() {
	checkGC();
	int[] result = null;
	if( lineDashes != null ) {
	result = new int[ lineDashes.length ];
	for( int i = 0; i < result.length; i++ ) {
	result[ i ] = ( int )lineDashes[ i ];
	}
	}
	return result;
	}

	public void setLineAttributes( final LineAttributes attributes ) {
	checkGC();
	if( attributes == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	boolean changed = false;
	float lineWidth = attributes.width;
	if( lineWidth != this.lineWidth ) {
	changed = true;
	}
	int lineStyle = attributes.style;
	if( lineStyle != this.lineStyle ) {
	changed = true;
	switch( lineStyle ) {
	case SWT.LINE_SOLID:
	case SWT.LINE_DASH:
	case SWT.LINE_DOT:
	case SWT.LINE_DASHDOT:
	case SWT.LINE_DASHDOTDOT:
	break;
	case SWT.LINE_CUSTOM:
	if( attributes.dash == null )
	lineStyle = SWT.LINE_SOLID;
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	}
	int join = attributes.join;
	if( join != this.lineJoin ) {
	changed = true;
	switch( join ) {
	case SWT.CAP_ROUND:
	case SWT.CAP_FLAT:
	case SWT.CAP_SQUARE:
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	}
	int cap = attributes.join;
	if( cap != this.lineCap ) {
	changed = true;
	switch( cap ) {
	case SWT.JOIN_MITER:
	case SWT.JOIN_ROUND:
	case SWT.JOIN_BEVEL:
	break;
	default:
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	}
	}
	float[] dashes = attributes.dash;
	float[] lineDashes = this.lineDashes;
	if( dashes != null && dashes.length > 0 ) {
	boolean dashesChanged = lineDashes == null
	\|\| lineDashes.length != dashes.length;
	for( int i = 0; i < dashes.length; i++ ) {
	float dash = dashes[ i ];
	if( dash <= 0 )
	SWT.error( SWT.ERROR_INVALID_ARGUMENT );
	if( !dashesChanged && lineDashes[ i ] != dash )
	dashesChanged = true;
	}
	if( dashesChanged ) {
	float[] newDashes = new float[ dashes.length ];
	System.arraycopy( dashes, 0, newDashes, 0, dashes.length );
	dashes = newDashes;
	changed = true;
	} else {
	dashes = lineDashes;
	}
	} else {
	if( lineDashes != null && lineDashes.length > 0 ) {
	changed = true;
	} else {
	dashes = lineDashes;
	}
	}
	float dashOffset = attributes.dashOffset;
	if( dashOffset != this.lineDashesOffset ) {
	changed = true;
	}
	float miterLimit = attributes.miterLimit;
	if( miterLimit != this.lineMiterLimit ) {
	changed = true;
	}
	if( changed ) {
	this.lineWidth = lineWidth;
	this.lineStyle = lineStyle;
	this.lineCap = cap;
	this.lineJoin = join;
	this.lineDashes = dashes;
	this.lineDashesOffset = dashOffset;
	this.lineMiterLimit = miterLimit;
	lineStroke = null;
	}
	}

	public LineAttributes getLineAttributes() {
	checkGC();
	float[] dashes = null;
	if( lineDashes != null ) {
	dashes = new float[ lineDashes.length ];
	System.arraycopy( lineDashes, 0, dashes, 0, dashes.length );
	}
	return new LineAttributes( lineWidth,
	lineCap,
	lineJoin,
	lineStyle,
	dashes,
	lineDashesOffset,
	lineMiterLimit );
	}

	// ////////////////
	// Drawing methods
	public void drawLine( final int x1, final int y1, final int x2, final int y2 )
	{
	checkGC();
	applyColor( foreground );
	applyLineStroke();
	Line2D.Float line = new Line2D.Float( x1, y1, x2, y2 );
	graphics.draw( line );
	}

	public void drawRectangle( final Rectangle rect ) {
	if( rect == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	drawRectangle( rect.x, rect.y, rect.width, rect.height );
	}

	public void drawRectangle( final int x,
	final int y,
	final int width,
	final int height )
	{
	checkGC();
	applyColor( foreground );
	graphics.drawRect( x, y, width - 1, height - 1 );
	}

	public void drawRoundRectangle( final int x,
	final int y,
	final int width,
	final int height,
	final int arcWidth,
	final int arcHeight )
	{
	checkGC();
	applyColor( foreground );
	graphics.drawRoundRect( x, y, width - 1, height - 1, arcWidth, arcHeight );
	}

	public void fillPolygon( int[] shapeArray ) {
	applyColor( background );
	graphics.fillPolygon( getPolygon( shapeArray ) );
	}

	public void drawPolygon( int[] shapeArray ) {
	applyColor( foreground );
	graphics.drawPolygon( getPolygon( shapeArray ) );
	}

	private Polygon getPolygon( int[] shapeArray ) {
	Polygon result = new Polygon();
	int numberOfPoints = shapeArray.length / 2;
	int[] xcoords = new int[ numberOfPoints ];
	int[] ycoords = new int[ numberOfPoints ];
	for( int i = 0; i <= numberOfPoints; i++ ) {
	xcoords[ i ] = shapeArray[ i ];
	xcoords[ i ] = shapeArray[ i + 1 ];
	}
	result.npoints = numberOfPoints;
	result.xpoints = xcoords;
	result.ypoints = ycoords;
	return result;
	}

	public void drawImage( final Image image, final int x, final int y ) {
	checkGC();
	if( image == null ) {
	SWT.error( SWT.ERROR_NULL_ARGUMENT );
	}
	BufferedImage awtImage = toAWTImage( image );
	graphics.drawImage( awtImage, x, y, null );
	}

	// ///////////////////////
	// dispose and isDisposed
	public void dispose() {
	writeImage();
	graphics.dispose();
	graphics = null;
	bufferedImage = null;
	image = null;
	}

	public boolean isDisposed() {
	return bufferedImage == null;
	}

	public String toString() {
	String result;
	if( isDisposed() ) {
	result = "GC {DISPOSED}";
	} else {
	result = "GC {" + bufferedImage + "}";
	}
	return result;
	}

	// ///////////////////////////////
	// Helping methods to write image
	private void writeImage() {
	ImageWriter writer = getImageWriter();
	File location = getImageResourceLocation( image );
	try {
	ImageOutputStream stream = ImageIO.createImageOutputStream( location );
	try {
	writer.setOutput( stream );
	writer.write( bufferedImage );
	} finally {
	stream.close();
	}
	} catch( IOException e ) {
	SWT.error( SWT.ERROR_IO, e );
	} finally {
	writer.dispose();
	}
	}

	private static ImageWriter getImageWriter() {
	ImageWriter result = null;
	Iterator imageWriters = ImageIO.getImageWritersByFormatName( IMAGE_FORMAT );
	if( imageWriters.hasNext() ) {
	result = ( ImageWriter )imageWriters.next();
	}
	if( result == null ) {
	SWT.error( SWT.ERROR_UNSUPPORTED_FORMAT, null, IMAGE_FORMAT );
	}
	return result;
	}

	private static File getImageResourceLocation( final Image image ) {
	IEngineConfig engineConfig = ConfigurationReader.getEngineConfig();
	File serverContextDir = engineConfig.getServerContextDir();
	String filename = "gen_" + image.hashCode();
	ResourceFactory.images.put( filename, image );
	return new File( serverContextDir, filename );
	}

	// /////////////////////////////
	// AWT Graphics Helping Methods
	private void applyColor( final Color color ) {
	graphics.setColor( toAWTColor( color ) );
	}

	private void applyLineStroke() {
	if( lineStroke == null ) {
	int awtLineCap = -1;
	switch( lineCap ) {
	case SWT.CAP_FLAT:
	awtLineCap = BasicStroke.CAP_BUTT;
	break;
	case SWT.CAP_ROUND:
	awtLineCap = BasicStroke.CAP_ROUND;
	break;
	case SWT.CAP_SQUARE:
	awtLineCap = BasicStroke.CAP_SQUARE;
	break;
	}
	int awtLineJoin = -1;
	switch( lineJoin ) {
	case SWT.JOIN_BEVEL:
	awtLineJoin = BasicStroke.JOIN_BEVEL;
	break;
	case SWT.JOIN_ROUND:
	awtLineJoin = BasicStroke.JOIN_ROUND;
	break;
	case SWT.JOIN_MITER:
	awtLineJoin = BasicStroke.JOIN_MITER;
	break;
	}
	float[] awtDashes = null;
	switch( lineStyle ) {
	case SWT.LINE_SOLID:
	break;
	case SWT.LINE_DASH:
	new UnsupportedOperationException( "dashes not yet implemented" );
	break;
	case SWT.LINE_DASHDOT:
	new UnsupportedOperationException( "dashes not yet implemented" );
	break;
	case SWT.LINE_DASHDOTDOT:
	new UnsupportedOperationException( "dashes not yet implemented" );
	break;
	case SWT.LINE_DOT:
	new UnsupportedOperationException( "dashes not yet implemented" );
	break;
	case SWT.LINE_CUSTOM:
	awtDashes = new float[ lineDashes.length ];
	for( int i = 0; i < lineDashes.length; i++ ) {
	awtDashes[ i ] = lineDashes[ i ];
	}
	break;
	}
	lineStroke = new BasicStroke( lineWidth,
	awtLineCap,
	awtLineJoin,
	lineMiterLimit,
	awtDashes,
	lineDashesOffset );
	graphics.setStroke( lineStroke );
	}
	}

	// //////////////////////
	// SWT to AWT conversion
	private static java.awt.Color toAWTColor( final Color color ) {
	return new java.awt.Color( color.getRed(),
	color.getGreen(),
	color.getBlue() );
	}

	private BufferedImage toAWTImage( final Image image ) {
	BufferedImage result = null;
	IResourceManager manager = ResourceManager.getInstance();
	String imagePath = ResourceFactory.getImagePath( image );
	try {
	InputStream inputStream = manager.getRegisteredContent( imagePath );
	try {
	boolean saveUseCache = ImageIO.getUseCache();
	ImageIO.setUseCache( false );
	try {
	result = ImageIO.read( inputStream );
	} finally {
	ImageIO.setUseCache( saveUseCache );
	}
	} finally {
	inputStream.close();
	}
	} catch( IOException e ) {
	String msg = "Failed to read input stream of image: " + imagePath;
	SWT.error( SWT.ERROR_IO, e, msg );
	}
	return result;
	}

	// ////////////////
	// Helping methods
	private void initDefaults() {
	// white background
	background = org.eclipse.rwt.graphics.Graphics.getColor( 255, 255, 255 );
	// black foreground
	foreground = org.eclipse.rwt.graphics.Graphics.getColor( 0, 0, 0 );
	// line attributes
	lineWidth = 0;
	lineCap = SWT.CAP_FLAT;
	lineJoin = SWT.JOIN_MITER;
	lineStyle = SWT.LINE_SOLID;
	lineDashes = null;
	lineDashesOffset = 0;
	lineMiterLimit = 10;
	// fill with default GC bg as the default Graphics bg is different
	Rectangle bounds = image.getBounds();
	applyColor( background );
	graphics.fillRect( 0, 0, bounds.width, image.getBounds().height );
	// set antialias to default
	graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING,
	RenderingHints.VALUE_ANTIALIAS_DEFAULT );
	}

	private void checkGC() {
	if( bufferedImage == null ) {
	SWT.error( SWT.ERROR_GRAPHIC_DISPOSED );
	}
	}

	private static BufferedImage createBufferedImage( final Image image ) {
	Rectangle bounds = image.getBounds();
	int type = BufferedImage.TYPE_INT_RGB;
	return new BufferedImage( bounds.width, bounds.height, type );
	}

	private static int checkStyle( final int style ) {
	// if ((style & SWT.LEFT_TO_RIGHT) != 0) style &= ~SWT.RIGHT_TO_LEFT;
	// return style & (SWT.LEFT_TO_RIGHT \| SWT.RIGHT_TO_LEFT);
	return style;
	}

	public Device getDevice() {
	return Display.getCurrent();
	}

	public void fillRoundRectangle( int x,
	int y,
	int width,
	int height,
	int arcWidth,
	int arcHeight )
	{
	checkGC();
	applyColor( background );
	graphics.fillRoundRect( x, y, width, height, arcWidth, arcHeight );
	}
	}