modules/swfutils/src/java/flash/graphics/g2d/SpriteGraphics2D.java - flex-sdk - Git at Google

 /*
  *
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */

 package flash.graphics.g2d;

 import flash.swf.tags.DefineShape;
 import flash.swf.tags.PlaceObject;
 import flash.swf.tags.DefineSprite;
 import flash.swf.tags.DefineBits;
 import flash.swf.tags.DefineBitsLossless;
 import flash.swf.builder.tags.DefineShapeBuilder;
 import flash.swf.builder.tags.DefineBitsLosslessBuilder;
 import flash.swf.builder.tags.DefineBitsBuilder;
 import flash.swf.builder.tags.ImageShapeBuilder;
 import flash.swf.builder.types.MatrixBuilder;
 import flash.swf.types.TagList;
 import flash.swf.types.Rect;
 import flash.swf.types.Matrix;
 import flash.swf.Tag;
 import flash.graphics.images.LosslessImage;
 import flash.graphics.images.JPEGImage;

 import java.awt.Shape;
 import java.awt.Graphics;
 import java.awt.Image;
 import java.awt.Paint;
 import java.awt.GradientPaint;
 import java.awt.image.ImageObserver;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.io.InputStream;
 import java.io.IOException;

 /**
  * A SWF specific implementation of Java2D's <code>Graphics2D</code>
  * API. Calls to this class are converted into a <code>TagList</code>
  * that can be used to construct a SWF Sprite.
  *
  * @author Peter Farland
  */
 public class SpriteGraphics2D extends AbstractGraphics2D
 {
 	/**
 	 * Constructor.
 	 * Initializes a new GraphicContext and TagList.
 	 *
 	 * @param width
 	 * @param height
 	 */
 	public SpriteGraphics2D(int width, int height)
 	{
 		super(new GraphicContext(width, height));
 		this.width = width;
 		this.height = height;
 		init();
 	}

 	/**
 	 * Optimized Constructor.
 	 * Initializes a smaller GraphicContext and TagList, without FontMetrics support.
 	 */
 	public SpriteGraphics2D()
 	{
 		super(new GraphicContext());
 		init();
 	}

 	private void init()
 	{
 		defineTags = new TagList();
 		graphicContext.validateTransformStack();
 		bounds = new Rect();
 	}

 	/**
 	 * Private Constructor - used by create().
 	 * @param swf2d
 	 * @see #create()
 	 */
 	private SpriteGraphics2D(SpriteGraphics2D swf2d)
 	{
 		super((GraphicContext)swf2d.graphicContext.clone());
 		bounds = new Rect();
 		defineTags = swf2d.getTags();
 	}

 	/**
 	 * Draws only the outline of an AWT Shape in SWF vectors using the settings of the
 	 * current graphics context and places it on the SWF display list. The current
 	 * stroke and paint colors are used to render the shape.
 	 * @param shape the shape to be drawn
 	 * @see java.awt.Graphics2D#draw(java.awt.Shape)
 	 */
 	public void draw(Shape shape)
 	{
 		defineShape(shape, true, false);
 	}

 	/**
 	 * Draws only the center of a closed AWT shape in SWF vectors using the settings of the
 	 * current graphic context and places it on the SWF display list. The current paint
 	 * is used to render the shape.
 	 * @param shape
 	 * @see java.awt.Graphics2D#fill(java.awt.Shape)
 	 */
 	public void fill(Shape shape)
 	{
 		defineShape(shape, false, true);
 	}

 	/**
 	 * This method converts an AWT Shape into a SWF Shape and creates a DefineShape3 instance
 	 * with an accompanying PlaceObject2 instance.
 	 * <p>
 	 * Two non-standard operations are performed to work around unavoidable issues. The first
 	 * is to apply the current AffineTransform before rendering and moving the drawing pen
 	 * origin to the first move command's location. The shape is correctly translated
 	 * to its intended location on the client by using the PlaceObject2's matrix.
 	 * </p>
 	 * <p>
 	 * The second issue is to deal with the incompatibility of SVGs viewport dimensions and
 	 * SWF Sprite auto-scaling. We have to keep track of the minimum area required to contain
 	 * the sprites manually, as using the viewport dimensions will produce unexpected scaling
 	 * for developers.
 	 * </p>
 	 * @param shape
 	 * @param draw
 	 * @param fill
 	 */
 	private void defineShape(Shape shape, boolean draw, boolean fill)
 	{
 		Point2D oldPen = null;
 		boolean isGradient = false;

 		if (fill && isGradientFill(graphicContext.getPaint()))
 			isGradient = true;

 		if (isGradient)
 		{
 			shape = graphicContext.getTransform().createTransformedShape(shape);
 			oldPen = graphicContext.setPen(getShapeStart(shape));
 		}

 		DefineShapeBuilder builder = new DefineShapeBuilder(shape, graphicContext, draw, fill);

 		DefineShape ds3 = (DefineShape)builder.build();
 		defineTags.defineShape3(ds3);

 		Matrix matrix;

 		if (isGradient)
 		{
 			double originX = graphicContext.getPen().getX();
 			double originY = graphicContext.getPen().getY();
 			matrix = MatrixBuilder.getTranslateInstance(originX, originY);
 		}
 		else
 		{
 		 	matrix = MatrixBuilder.build(graphicContext.getTransform());
 		}

 		applyBounds(ds3.bounds.xMin + matrix.translateX,
 				ds3.bounds.yMin + matrix.translateY,
 				ds3.bounds.xMax + matrix.translateX,
 				ds3.bounds.yMax + matrix.translateY);

 		PlaceObject po2 = new PlaceObject(Tag.stagPlaceObject2);
 		po2.setMatrix(matrix);
 		po2.setRef(ds3);
         po2.depth = depth++;

 		if (isGradient)
 			graphicContext.setPen(oldPen);

 		defineTags.placeObject2(po2);
 	}

 	/**
 	 * <b style="color:orange">NOT YET IMPLEMENTED AS DEFINED BELOW, CURRENTLY USING drawStringAsShape()</b><br />
 	 * Renders the text specified as a series of SWF character glyphs,
 	 * using the current graphic context to control anti-aliasing and color.
 	 * Unique glyphs are stored in a SWF font definition, and the defined text
 	 * references this by index.
 	 * <p>
 	 * The baseline of the first character is at position (<i>x</i>, <i>y</i>)
 	 * in the User Space.
 	 * </p>
 	 * @param str the text to be rendered
 	 * @param x baseline x co-ordinate
 	 * @param y baseline y co-ordinate
 	 * @see java.awt.Graphics2D#drawString(java.lang.String, float, float)
 	 */
 	public void drawString(String str, float x, float y)
 	{
 		drawStringAsShape(str, x, y);
 	}

 	public void drawString(String str, int x, int y)
 	{
 		super.drawString(str, x, y);
 	}

 	public boolean drawImage(Image image, AffineTransform at, ImageObserver obs)
 	{
 		if (image != null)
 		{
 		    LosslessImage losslessImage = new LosslessImage(image);
 		    int width = losslessImage.getWidth();
 		    int height = losslessImage.getHeight();
 			DefineBitsLossless defineBits = DefineBitsLosslessBuilder.build(losslessImage.getPixels(), width, height);
 			defineTags.defineBitsLossless2(defineBits);

 			DefineShape ds3 = ImageShapeBuilder.buildImage(defineBits, defineBits.width, defineBits.height);
 			defineTags.defineShape3(ds3);
 			applyBounds(ds3.bounds.xMin, ds3.bounds.yMin, ds3.bounds.xMax, ds3.bounds.yMax);

 			PlaceObject po2 = new PlaceObject(Tag.stagPlaceObject2);
 			po2.setMatrix(MatrixBuilder.build(at));
 			po2.setRef(ds3);
 			po2.depth = depth++;

 			defineTags.placeObject2(po2);
 		}

 		return false;
 	}

 	public boolean drawImage(Image image, int x, int y, ImageObserver observer)
 	{
 		AffineTransform at = graphicContext.getTransform();
 		at.translate(x, y);
 		return drawImage(image, at, observer);
 	}

 	public boolean drawImage(Image image, int x, int y, int width, int height, ImageObserver observer)
 	{
 		AffineTransform at = graphicContext.getTransform();
 		at.translate(x, y);
 		double sx = (double)width/(double)image.getWidth(observer);
 		double sy = (double)height/(double)image.getHeight(observer);
 		at.scale(sx, sy);
 		return drawImage(image, at, observer);
 	}

     /**
 	 * Converts an AWT image into a SWF <code>DefineBitsLossless</code> tag and adds it to
 	 * the Sprite <code>TagList</code> context.
 	 *
 	 * @param image - an AWT bitmapped image
 	 * @param name - name to use in the corresponding <code>PlaceObject</code> tag
 	 */
 	public void drawNamedImage(Image image, String name)
 	{
 		if (image != null)
 		{
             LosslessImage losslessImage = new LosslessImage(image);
             int width = losslessImage.getWidth();
             int height = losslessImage.getHeight();
             DefineBitsLossless defineBits = DefineBitsLosslessBuilder.build(losslessImage.getPixels(), width, height);
 			defineTags.defineBitsLossless2(defineBits);

 			DefineShape ds3 = ImageShapeBuilder.buildImage(defineBits, defineBits.width, defineBits.height);
 			defineTags.defineShape3(ds3);
             applyBounds(ds3.bounds.xMin, ds3.bounds.yMin, ds3.bounds.xMax, ds3.bounds.yMax);

 			PlaceObject po2 = new PlaceObject(ds3, depth++);
             po2.setMatrix(MatrixBuilder.build(graphicContext.getTransform()));
             po2.setName(name);

 			defineTags.placeObject2(po2);
 		}
 	}


 	/**
 	 * Converts a JPEG binary input stream into a SWF <code>DefineBits</code> tag and adds it
 	 * to the Sprite <code>TagList</code> context.
 	 *
 	 * @param inputStream - the raw JPEG binary stream
 	 * @param length - number of bits to read from the stream
 	 * @param width - width of the JPEG image in pixels
 	 * @param height - height of the JPEG image in pixels
 	 * @param name - name to use in the corresponding <code>PlaceObject</code> tag
 	 * @throws IOException
 	 */
 	public void drawJPEG(InputStream inputStream, int length, int width, int height, String name) throws IOException
 	{
         if (inputStream != null)
 		{
 			try
 			{
                 JPEGImage image = new JPEGImage(inputStream, length);
                 DefineBits defineBits = new DefineBits(Tag.stagDefineBitsJPEG2);
                 defineBits.data = image.getData();
 				defineTags.defineBitsJPEG2(defineBits);

 				DefineShape ds3 = ImageShapeBuilder.buildImage(defineBits, width, height);
 				defineTags.defineShape3(ds3);
 				applyBounds(ds3.bounds.xMin, ds3.bounds.yMin, ds3.bounds.xMax, ds3.bounds.yMax);

                 PlaceObject po2 = new PlaceObject(ds3, depth++);
                 po2.setMatrix(MatrixBuilder.build(graphicContext.getTransform()));
                 po2.setName(name);

 				defineTags.placeObject2(po2);
 			}
 			finally
 			{
 				try
 				{
 					inputStream.close();
 				}
 				catch (IOException e)
 				{
 				}
 			}
 		}
 	}

 	/**
 	 * Creates a new <code>Graphics</code> object that is a copy of
 	 * this <code>SpriteGraphics2D</code> object.
 	 * @return a copy of this Graphics2D instance
 	 */
 	public Graphics create()
 	{
 		return new SpriteGraphics2D(this);
 	}

 	public TagList getTags()
 	{
 		return defineTags;
 	}

 	public int getWidth()
 	{
 		return width;
 	}

 	public int getHeight()
 	{
 		return height;
 	}

 	public DefineSprite defineSprite(String name)
 	{
 		DefineSprite defineSprite = new DefineSprite();
 		defineSprite.framecount = 1;
 		defineSprite.tagList = defineTags;
 		defineSprite.name = name;
 		return defineSprite;
 	}

 	private static boolean isGradientFill(Paint paint)
 	{
 		return (paint != null
 				&& (paint instanceof GradientPaint
 						|| paint.getClass().getName().equals("org.apache.flex.forks.batik.ext.awt.MultipleGradientPaint")));
 	}

 	/**
 	 * When trying to negate gradient dilution in filled SWF shapes, it is useful to
 	 * know where the left most point of the physical shape as this can be used to change
 	 * the drawing origin to minimize non-drawing move commands contributing to the
 	 * shape bounds.
 	 *
 	 * @param shape
 	 * @return Point2D the minimum x,y position of this shape's bounds.
 	 */
 	private static Point2D getShapeStart(Shape shape)
 	{
 		if (shape != null)
 		{
 			Rectangle2D bounds = shape.getBounds2D();
 			return new Point2D.Double(bounds.getMinX(), bounds.getMinY());
 		}

 		return new Point2D.Double(0, 0);
 	}

 	private void applyBounds(int x1, int y1, int x2, int y2)
 	{
 		if (x1 < bounds.xMin) bounds.xMin = x1;
 		if (y1 < bounds.yMin) bounds.yMin = y1;
 		if (x1 > bounds.xMax) bounds.xMax = x1;
 		if (y1 > bounds.yMax) bounds.yMax = y1;
 		if (x2 < bounds.xMin) bounds.xMin = x2;
 		if (y2 < bounds.yMin) bounds.yMin = y2;
 		if (x2 > bounds.xMax) bounds.xMax = x2;
 		if (y2 > bounds.yMax) bounds.yMax = y2;
 	}

 	public Rect getBounds()
 	{
 		return bounds;
 	}

 	protected TagList defineTags;
 	protected int depth = 1;
 	protected int width;
 	protected int height;
 	protected Rect bounds;
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	package flash.graphics.g2d;

	import flash.swf.tags.DefineShape;
	import flash.swf.tags.PlaceObject;
	import flash.swf.tags.DefineSprite;
	import flash.swf.tags.DefineBits;
	import flash.swf.tags.DefineBitsLossless;
	import flash.swf.builder.tags.DefineShapeBuilder;
	import flash.swf.builder.tags.DefineBitsLosslessBuilder;
	import flash.swf.builder.tags.DefineBitsBuilder;
	import flash.swf.builder.tags.ImageShapeBuilder;
	import flash.swf.builder.types.MatrixBuilder;
	import flash.swf.types.TagList;
	import flash.swf.types.Rect;
	import flash.swf.types.Matrix;
	import flash.swf.Tag;
	import flash.graphics.images.LosslessImage;
	import flash.graphics.images.JPEGImage;

	import java.awt.Shape;
	import java.awt.Graphics;
	import java.awt.Image;
	import java.awt.Paint;
	import java.awt.GradientPaint;
	import java.awt.image.ImageObserver;
	import java.awt.geom.AffineTransform;
	import java.awt.geom.Point2D;
	import java.awt.geom.Rectangle2D;
	import java.io.InputStream;
	import java.io.IOException;

	/**
	* A SWF specific implementation of Java2D's <code>Graphics2D</code>
	* API. Calls to this class are converted into a <code>TagList</code>
	* that can be used to construct a SWF Sprite.
	*
	* @author Peter Farland
	*/
	public class SpriteGraphics2D extends AbstractGraphics2D
	{
	/**
	* Constructor.
	* Initializes a new GraphicContext and TagList.
	*
	* @param width
	* @param height
	*/
	public SpriteGraphics2D(int width, int height)
	{
	super(new GraphicContext(width, height));
	this.width = width;
	this.height = height;
	init();
	}

	/**
	* Optimized Constructor.
	* Initializes a smaller GraphicContext and TagList, without FontMetrics support.
	*/
	public SpriteGraphics2D()
	{
	super(new GraphicContext());
	init();
	}

	private void init()
	{
	defineTags = new TagList();
	graphicContext.validateTransformStack();
	bounds = new Rect();
	}

	/**
	* Private Constructor - used by create().
	* @param swf2d
	* @see #create()
	*/
	private SpriteGraphics2D(SpriteGraphics2D swf2d)
	{
	super((GraphicContext)swf2d.graphicContext.clone());
	bounds = new Rect();
	defineTags = swf2d.getTags();
	}

	/**
	* Draws only the outline of an AWT Shape in SWF vectors using the settings of the
	* current graphics context and places it on the SWF display list. The current
	* stroke and paint colors are used to render the shape.
	* @param shape the shape to be drawn
	* @see java.awt.Graphics2D#draw(java.awt.Shape)
	*/
	public void draw(Shape shape)
	{
	defineShape(shape, true, false);
	}

	/**
	* Draws only the center of a closed AWT shape in SWF vectors using the settings of the
	* current graphic context and places it on the SWF display list. The current paint
	* is used to render the shape.
	* @param shape
	* @see java.awt.Graphics2D#fill(java.awt.Shape)
	*/
	public void fill(Shape shape)
	{
	defineShape(shape, false, true);
	}

	/**
	* This method converts an AWT Shape into a SWF Shape and creates a DefineShape3 instance
	* with an accompanying PlaceObject2 instance.
	* <p>
	* Two non-standard operations are performed to work around unavoidable issues. The first
	* is to apply the current AffineTransform before rendering and moving the drawing pen
	* origin to the first move command's location. The shape is correctly translated
	* to its intended location on the client by using the PlaceObject2's matrix.
	* </p>
	* <p>
	* The second issue is to deal with the incompatibility of SVGs viewport dimensions and
	* SWF Sprite auto-scaling. We have to keep track of the minimum area required to contain
	* the sprites manually, as using the viewport dimensions will produce unexpected scaling
	* for developers.
	* </p>
	* @param shape
	* @param draw
	* @param fill
	*/
	private void defineShape(Shape shape, boolean draw, boolean fill)
	{
	Point2D oldPen = null;
	boolean isGradient = false;

	if (fill && isGradientFill(graphicContext.getPaint()))
	isGradient = true;

	if (isGradient)
	{
	shape = graphicContext.getTransform().createTransformedShape(shape);
	oldPen = graphicContext.setPen(getShapeStart(shape));
	}

	DefineShapeBuilder builder = new DefineShapeBuilder(shape, graphicContext, draw, fill);

	DefineShape ds3 = (DefineShape)builder.build();
	defineTags.defineShape3(ds3);

	Matrix matrix;

	if (isGradient)
	{
	double originX = graphicContext.getPen().getX();
	double originY = graphicContext.getPen().getY();
	matrix = MatrixBuilder.getTranslateInstance(originX, originY);
	}
	else
	{
	matrix = MatrixBuilder.build(graphicContext.getTransform());
	}

	applyBounds(ds3.bounds.xMin + matrix.translateX,
	ds3.bounds.yMin + matrix.translateY,
	ds3.bounds.xMax + matrix.translateX,
	ds3.bounds.yMax + matrix.translateY);

	PlaceObject po2 = new PlaceObject(Tag.stagPlaceObject2);
	po2.setMatrix(matrix);
	po2.setRef(ds3);
	po2.depth = depth++;

	if (isGradient)
	graphicContext.setPen(oldPen);

	defineTags.placeObject2(po2);
	}

	/**
	* <b style="color:orange">NOT YET IMPLEMENTED AS DEFINED BELOW, CURRENTLY USING drawStringAsShape()</b><br />
	* Renders the text specified as a series of SWF character glyphs,
	* using the current graphic context to control anti-aliasing and color.
	* Unique glyphs are stored in a SWF font definition, and the defined text
	* references this by index.
	* <p>
	* The baseline of the first character is at position (<i>x</i>, <i>y</i>)
	* in the User Space.
	* </p>
	* @param str the text to be rendered
	* @param x baseline x co-ordinate
	* @param y baseline y co-ordinate
	* @see java.awt.Graphics2D#drawString(java.lang.String, float, float)
	*/
	public void drawString(String str, float x, float y)
	{
	drawStringAsShape(str, x, y);
	}

	public void drawString(String str, int x, int y)
	{
	super.drawString(str, x, y);
	}

	public boolean drawImage(Image image, AffineTransform at, ImageObserver obs)
	{
	if (image != null)
	{
	LosslessImage losslessImage = new LosslessImage(image);
	int width = losslessImage.getWidth();
	int height = losslessImage.getHeight();
	DefineBitsLossless defineBits = DefineBitsLosslessBuilder.build(losslessImage.getPixels(), width, height);
	defineTags.defineBitsLossless2(defineBits);

	DefineShape ds3 = ImageShapeBuilder.buildImage(defineBits, defineBits.width, defineBits.height);
	defineTags.defineShape3(ds3);
	applyBounds(ds3.bounds.xMin, ds3.bounds.yMin, ds3.bounds.xMax, ds3.bounds.yMax);

	PlaceObject po2 = new PlaceObject(Tag.stagPlaceObject2);
	po2.setMatrix(MatrixBuilder.build(at));
	po2.setRef(ds3);
	po2.depth = depth++;

	defineTags.placeObject2(po2);
	}

	return false;
	}

	public boolean drawImage(Image image, int x, int y, ImageObserver observer)
	{
	AffineTransform at = graphicContext.getTransform();
	at.translate(x, y);
	return drawImage(image, at, observer);
	}

	public boolean drawImage(Image image, int x, int y, int width, int height, ImageObserver observer)
	{
	AffineTransform at = graphicContext.getTransform();
	at.translate(x, y);
	double sx = (double)width/(double)image.getWidth(observer);
	double sy = (double)height/(double)image.getHeight(observer);
	at.scale(sx, sy);
	return drawImage(image, at, observer);
	}

	/**
	* Converts an AWT image into a SWF <code>DefineBitsLossless</code> tag and adds it to
	* the Sprite <code>TagList</code> context.
	*
	* @param image - an AWT bitmapped image
	* @param name - name to use in the corresponding <code>PlaceObject</code> tag
	*/
	public void drawNamedImage(Image image, String name)
	{
	if (image != null)
	{
	LosslessImage losslessImage = new LosslessImage(image);
	int width = losslessImage.getWidth();
	int height = losslessImage.getHeight();
	DefineBitsLossless defineBits = DefineBitsLosslessBuilder.build(losslessImage.getPixels(), width, height);
	defineTags.defineBitsLossless2(defineBits);

	DefineShape ds3 = ImageShapeBuilder.buildImage(defineBits, defineBits.width, defineBits.height);
	defineTags.defineShape3(ds3);
	applyBounds(ds3.bounds.xMin, ds3.bounds.yMin, ds3.bounds.xMax, ds3.bounds.yMax);

	PlaceObject po2 = new PlaceObject(ds3, depth++);
	po2.setMatrix(MatrixBuilder.build(graphicContext.getTransform()));
	po2.setName(name);

	defineTags.placeObject2(po2);
	}
	}


	/**
	* Converts a JPEG binary input stream into a SWF <code>DefineBits</code> tag and adds it
	* to the Sprite <code>TagList</code> context.
	*
	* @param inputStream - the raw JPEG binary stream
	* @param length - number of bits to read from the stream
	* @param width - width of the JPEG image in pixels
	* @param height - height of the JPEG image in pixels
	* @param name - name to use in the corresponding <code>PlaceObject</code> tag
	* @throws IOException
	*/
	public void drawJPEG(InputStream inputStream, int length, int width, int height, String name) throws IOException
	{
	if (inputStream != null)
	{
	try
	{
	JPEGImage image = new JPEGImage(inputStream, length);
	DefineBits defineBits = new DefineBits(Tag.stagDefineBitsJPEG2);
	defineBits.data = image.getData();
	defineTags.defineBitsJPEG2(defineBits);

	DefineShape ds3 = ImageShapeBuilder.buildImage(defineBits, width, height);
	defineTags.defineShape3(ds3);
	applyBounds(ds3.bounds.xMin, ds3.bounds.yMin, ds3.bounds.xMax, ds3.bounds.yMax);

	PlaceObject po2 = new PlaceObject(ds3, depth++);
	po2.setMatrix(MatrixBuilder.build(graphicContext.getTransform()));
	po2.setName(name);

	defineTags.placeObject2(po2);
	}
	finally
	{
	try
	{
	inputStream.close();
	}
	catch (IOException e)
	{
	}
	}
	}
	}

	/**
	* Creates a new <code>Graphics</code> object that is a copy of
	* this <code>SpriteGraphics2D</code> object.
	* @return a copy of this Graphics2D instance
	*/
	public Graphics create()
	{
	return new SpriteGraphics2D(this);
	}

	public TagList getTags()
	{
	return defineTags;
	}

	public int getWidth()
	{
	return width;
	}

	public int getHeight()
	{
	return height;
	}

	public DefineSprite defineSprite(String name)
	{
	DefineSprite defineSprite = new DefineSprite();
	defineSprite.framecount = 1;
	defineSprite.tagList = defineTags;
	defineSprite.name = name;
	return defineSprite;
	}

	private static boolean isGradientFill(Paint paint)
	{
	return (paint != null
	&& (paint instanceof GradientPaint
	\|\| paint.getClass().getName().equals("org.apache.flex.forks.batik.ext.awt.MultipleGradientPaint")));
	}

	/**
	* When trying to negate gradient dilution in filled SWF shapes, it is useful to
	* know where the left most point of the physical shape as this can be used to change
	* the drawing origin to minimize non-drawing move commands contributing to the
	* shape bounds.
	*
	* @param shape
	* @return Point2D the minimum x,y position of this shape's bounds.
	*/
	private static Point2D getShapeStart(Shape shape)
	{
	if (shape != null)
	{
	Rectangle2D bounds = shape.getBounds2D();
	return new Point2D.Double(bounds.getMinX(), bounds.getMinY());
	}

	return new Point2D.Double(0, 0);
	}

	private void applyBounds(int x1, int y1, int x2, int y2)
	{
	if (x1 < bounds.xMin) bounds.xMin = x1;
	if (y1 < bounds.yMin) bounds.yMin = y1;
	if (x1 > bounds.xMax) bounds.xMax = x1;
	if (y1 > bounds.yMax) bounds.yMax = y1;
	if (x2 < bounds.xMin) bounds.xMin = x2;
	if (y2 < bounds.yMin) bounds.yMin = y2;
	if (x2 > bounds.xMax) bounds.xMax = x2;
	if (y2 > bounds.yMax) bounds.yMax = y2;
	}

	public Rect getBounds()
	{
	return bounds;
	}

	protected TagList defineTags;
	protected int depth = 1;
	protected int width;
	protected int height;
	protected Rect bounds;
	}