My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/print/PathGraphics.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/print/PathGraphics.java+1896−0

@@ -0,0 +1,1896 @@
	1	/*
	2	* Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package sun.print;
	27
	28	import java.lang.ref.SoftReference;
	29	import java.util.Hashtable;
	30	import sun.font.CharToGlyphMapper;
	31	import sun.font.CompositeFont;
	32	import sun.font.Font2D;
	33	import sun.font.Font2DHandle;
	34	import sun.font.FontManager;
	35	import sun.font.FontManagerFactory;
	36	import sun.font.FontUtilities;
	37
	38	import java.awt.Color;
	39	import java.awt.Font;
	40	import java.awt.Graphics2D;
	41	import java.awt.Image;
	42	import java.awt.Paint;
	43	import java.awt.Polygon;
	44	import java.awt.Shape;
	45
	46	import java.text.AttributedCharacterIterator;
	47
	48	import java.awt.font.FontRenderContext;
	49	import java.awt.font.GlyphVector;
	50	import java.awt.font.TextAttribute;
	51	import java.awt.font.TextLayout;
	52
	53	import java.awt.geom.AffineTransform;
	54	import java.awt.geom.Arc2D;
	55	import java.awt.geom.Ellipse2D;
	56	import java.awt.geom.Line2D;
	57	import java.awt.geom.Point2D;
	58	import java.awt.geom.Rectangle2D;
	59	import java.awt.geom.RoundRectangle2D;
	60	import java.awt.geom.PathIterator;
	61
	62	import java.awt.image.BufferedImage;
	63	import java.awt.image.BufferedImageOp;
	64	import java.awt.image.ColorModel;
	65	import java.awt.image.DataBuffer;
	66	import java.awt.image.DataBufferInt;
	67	import java.awt.image.ImageObserver;
	68	import java.awt.image.IndexColorModel;
	69	import java.awt.image.Raster;
	70	import java.awt.image.RenderedImage;
	71	import java.awt.image.SampleModel;
	72	import java.awt.image.SinglePixelPackedSampleModel;
	73	import java.awt.image.VolatileImage;
	74	import sun.awt.image.ByteComponentRaster;
	75	import sun.awt.image.ToolkitImage;
	76	import sun.awt.image.SunWritableRaster;
	77
	78	import java.awt.print.PageFormat;
	79	import java.awt.print.Printable;
	80	import java.awt.print.PrinterException;
	81	import java.awt.print.PrinterGraphics;
	82	import java.awt.print.PrinterJob;
	83
	84	import java.util.Map;
	85
	86	public abstract class PathGraphics extends ProxyGraphics2D {
	87
	88	private Printable mPainter;
	89	private PageFormat mPageFormat;
	90	private int mPageIndex;
	91	private boolean mCanRedraw;
	92	protected boolean printingGlyphVector;
	93
	94	protected PathGraphics(Graphics2D graphics, PrinterJob printerJob,
	95	Printable painter, PageFormat pageFormat,
	96	int pageIndex, boolean canRedraw) {
	97	super(graphics, printerJob);
	98
	99	mPainter = painter;
	100	mPageFormat = pageFormat;
	101	mPageIndex = pageIndex;
	102	mCanRedraw = canRedraw;
	103	}
	104
	105	/**
	106	* Return the Printable instance responsible for drawing
	107	* into this Graphics.
	108	*/
	109	protected Printable getPrintable() {
	110	return mPainter;
	111	}
	112
	113	/**
	114	* Return the PageFormat associated with this page of
	115	* Graphics.
	116	*/
	117	protected PageFormat getPageFormat() {
	118	return mPageFormat;
	119	}
	120
	121	/**
	122	* Return the page index associated with this Graphics.
	123	*/
	124	protected int getPageIndex() {
	125	return mPageIndex;
	126	}
	127
	128	/**
	129	* Return true if we are allowed to ask the application
	130	* to redraw portions of the page. In general, with the
	131	* PrinterJob API, the application can be asked to do a
	132	* redraw. When PrinterJob is emulating PrintJob then we
	133	* can not.
	134	*/
	135	public boolean canDoRedraws() {
	136	return mCanRedraw;
	137	}
	138
	139	/**
	140	* Redraw a rectanglular area using a proxy graphics
	141	*/
	142	public abstract void redrawRegion(Rectangle2D region,
	143	double scaleX, double scaleY,
	144	Shape clip,
	145	AffineTransform devTransform)
	146
	147	throws PrinterException ;
	148
	149	/**
	150	* Draws a line, using the current color, between the points
	151	* <code>(x1, y1)</code> and <code>(x2, y2)</code>
	152	* in this graphics context's coordinate system.
	153	* @param x1 the first point's <i>x</i> coordinate.
	154	* @param y1 the first point's <i>y</i> coordinate.
	155	* @param x2 the second point's <i>x</i> coordinate.
	156	* @param y2 the second point's <i>y</i> coordinate.
	157	*/
	158	public void drawLine(int x1, int y1, int x2, int y2) {
	159
	160	Paint paint = getPaint();
	161
	162	try {
	163	AffineTransform deviceTransform = getTransform();
	164	if (getClip() != null) {
	165	deviceClip(getClip().getPathIterator(deviceTransform));
	166	}
	167
	168	deviceDrawLine(x1, y1, x2, y2, (Color) paint);
	169
	170	} catch (ClassCastException e) {
	171	throw new IllegalArgumentException("Expected a Color instance");
	172	}
	173	}
	174
	175
	176	/**
	177	* Draws the outline of the specified rectangle.
	178	* The left and right edges of the rectangle are at
	179	* <code>x</code> and <code>x + width</code>.
	180	* The top and bottom edges are at
	181	* <code>y</code> and <code>y + height</code>.
	182	* The rectangle is drawn using the graphics context's current color.
	183	* @param x the <i>x</i> coordinate
	184	* of the rectangle to be drawn.
	185	* @param y the <i>y</i> coordinate
	186	* of the rectangle to be drawn.
	187	* @param width the width of the rectangle to be drawn.
	188	* @param height the height of the rectangle to be drawn.
	189	* @see java.awt.Graphics#fillRect
	190	* @see java.awt.Graphics#clearRect
	191	*/
	192	public void drawRect(int x, int y, int width, int height) {
	193
	194	Paint paint = getPaint();
	195
	196	try {
	197	AffineTransform deviceTransform = getTransform();
	198	if (getClip() != null) {
	199	deviceClip(getClip().getPathIterator(deviceTransform));
	200	}
	201
	202	deviceFrameRect(x, y, width, height, (Color) paint);
	203
	204	} catch (ClassCastException e) {
	205	throw new IllegalArgumentException("Expected a Color instance");
	206	}
	207
	208	}
	209
	210	/**
	211	* Fills the specified rectangle.
	212	* The left and right edges of the rectangle are at
	213	* <code>x</code> and <code>x + width - 1</code>.
	214	* The top and bottom edges are at
	215	* <code>y</code> and <code>y + height - 1</code>.
	216	* The resulting rectangle covers an area
	217	* <code>width</code> pixels wide by
	218	* <code>height</code> pixels tall.
	219	* The rectangle is filled using the graphics context's current color.
	220	* @param x the <i>x</i> coordinate
	221	* of the rectangle to be filled.
	222	* @param y the <i>y</i> coordinate
	223	* of the rectangle to be filled.
	224	* @param width the width of the rectangle to be filled.
	225	* @param height the height of the rectangle to be filled.
	226	* @see java.awt.Graphics#clearRect
	227	* @see java.awt.Graphics#drawRect
	228	*/
	229	public void fillRect(int x, int y, int width, int height){
	230
	231	Paint paint = getPaint();
	232
	233	try {
	234	AffineTransform deviceTransform = getTransform();
	235	if (getClip() != null) {
	236	deviceClip(getClip().getPathIterator(deviceTransform));
	237	}
	238
	239	deviceFillRect(x, y, width, height, (Color) paint);
	240
	241	} catch (ClassCastException e) {
	242	throw new IllegalArgumentException("Expected a Color instance");
	243	}
	244	}
	245
	246	/**
	247	* Clears the specified rectangle by filling it with the background
	248	* color of the current drawing surface. This operation does not
	249	* use the current paint mode.
	250	* <p>
	251	* Beginning with Java 1.1, the background color
	252	* of offscreen images may be system dependent. Applications should
	253	* use <code>setColor</code> followed by <code>fillRect</code> to
	254	* ensure that an offscreen image is cleared to a specific color.
	255	* @param x the <i>x</i> coordinate of the rectangle to clear.
	256	* @param y the <i>y</i> coordinate of the rectangle to clear.
	257	* @param width the width of the rectangle to clear.
	258	* @param height the height of the rectangle to clear.
	259	* @see java.awt.Graphics#fillRect(int, int, int, int)
	260	* @see java.awt.Graphics#drawRect
	261	* @see java.awt.Graphics#setColor(java.awt.Color)
	262	* @see java.awt.Graphics#setPaintMode
	263	* @see java.awt.Graphics#setXORMode(java.awt.Color)
	264	*/
	265	public void clearRect(int x, int y, int width, int height) {
	266
	267	fill(new Rectangle2D.Float(x, y, width, height), getBackground());
	268	}
	269
	270	/**
	271	* Draws an outlined round-cornered rectangle using this graphics
	272	* context's current color. The left and right edges of the rectangle
	273	* are at <code>x</code> and <code>x + width</code>,
	274	* respectively. The top and bottom edges of the rectangle are at
	275	* <code>y</code> and <code>y + height</code>.
	276	* @param x the <i>x</i> coordinate of the rectangle to be drawn.
	277	* @param y the <i>y</i> coordinate of the rectangle to be drawn.
	278	* @param width the width of the rectangle to be drawn.
	279	* @param height the height of the rectangle to be drawn.
	280	* @param arcWidth the horizontal diameter of the arc
	281	* at the four corners.
	282	* @param arcHeight the vertical diameter of the arc
	283	* at the four corners.
	284	* @see java.awt.Graphics#fillRoundRect
	285	*/
	286	public void drawRoundRect(int x, int y, int width, int height,
	287	int arcWidth, int arcHeight) {
	288
	289	draw(new RoundRectangle2D.Float(x, y,
	290	width, height,
	291	arcWidth, arcHeight));
	292	}
	293
	294
	295	/**
	296	* Fills the specified rounded corner rectangle with the current color.
	297	* The left and right edges of the rectangle
	298	* are at <code>x</code> and <code>x + width - 1</code>,
	299	* respectively. The top and bottom edges of the rectangle are at
	300	* <code>y</code> and <code>y + height - 1</code>.
	301	* @param x the <i>x</i> coordinate of the rectangle to be filled.
	302	* @param y the <i>y</i> coordinate of the rectangle to be filled.
	303	* @param width the width of the rectangle to be filled.
	304	* @param height the height of the rectangle to be filled.
	305	* @param arcWidth the horizontal diameter
	306	* of the arc at the four corners.
	307	* @param arcHeight the vertical diameter
	308	* of the arc at the four corners.
	309	* @see java.awt.Graphics#drawRoundRect
	310	*/
	311	public void fillRoundRect(int x, int y, int width, int height,
	312	int arcWidth, int arcHeight) {
	313
	314	fill(new RoundRectangle2D.Float(x, y,
	315	width, height,
	316	arcWidth, arcHeight));
	317	}
	318
	319	/**
	320	* Draws the outline of an oval.
	321	* The result is a circle or ellipse that fits within the
	322	* rectangle specified by the <code>x</code>, <code>y</code>,
	323	* <code>width</code>, and <code>height</code> arguments.
	324	* <p>
	325	* The oval covers an area that is
	326	* <code>width + 1</code> pixels wide
	327	* and <code>height + 1</code> pixels tall.
	328	* @param x the <i>x</i> coordinate of the upper left
	329	* corner of the oval to be drawn.
	330	* @param y the <i>y</i> coordinate of the upper left
	331	* corner of the oval to be drawn.
	332	* @param width the width of the oval to be drawn.
	333	* @param height the height of the oval to be drawn.
	334	* @see java.awt.Graphics#fillOval
	335	* @since JDK1.0
	336	*/
	337	public void drawOval(int x, int y, int width, int height) {
	338	draw(new Ellipse2D.Float(x, y, width, height));
	339	}
	340
	341	/**
	342	* Fills an oval bounded by the specified rectangle with the
	343	* current color.
	344	* @param x the <i>x</i> coordinate of the upper left corner
	345	* of the oval to be filled.
	346	* @param y the <i>y</i> coordinate of the upper left corner
	347	* of the oval to be filled.
	348	* @param width the width of the oval to be filled.
	349	* @param height the height of the oval to be filled.
	350	* @see java.awt.Graphics#drawOval
	351	*/
	352	public void fillOval(int x, int y, int width, int height){
	353
	354	fill(new Ellipse2D.Float(x, y, width, height));
	355	}
	356
	357	/**
	358	* Draws the outline of a circular or elliptical arc
	359	* covering the specified rectangle.
	360	* <p>
	361	* The resulting arc begins at <code>startAngle</code> and extends
	362	* for <code>arcAngle</code> degrees, using the current color.
	363	* Angles are interpreted such that 0 degrees
	364	* is at the 3 o'clock position.
	365	* A positive value indicates a counter-clockwise rotation
	366	* while a negative value indicates a clockwise rotation.
	367	* <p>
	368	* The center of the arc is the center of the rectangle whose origin
	369	* is (<i>x</i>, <i>y</i>) and whose size is specified by the
	370	* <code>width</code> and <code>height</code> arguments.
	371	* <p>
	372	* The resulting arc covers an area
	373	* <code>width + 1</code> pixels wide
	374	* by <code>height + 1</code> pixels tall.
	375	* <p>
	376	* The angles are specified relative to the non-square extents of
	377	* the bounding rectangle such that 45 degrees always falls on the
	378	* line from the center of the ellipse to the upper right corner of
	379	* the bounding rectangle. As a result, if the bounding rectangle is
	380	* noticeably longer in one axis than the other, the angles to the
	381	* start and end of the arc segment will be skewed farther along the
	382	* longer axis of the bounds.
	383	* @param x the <i>x</i> coordinate of the
	384	* upper-left corner of the arc to be drawn.
	385	* @param y the <i>y</i> coordinate of the
	386	* upper-left corner of the arc to be drawn.
	387	* @param width the width of the arc to be drawn.
	388	* @param height the height of the arc to be drawn.
	389	* @param startAngle the beginning angle.
	390	* @param arcAngle the angular extent of the arc,
	391	* relative to the start angle.
	392	* @see java.awt.Graphics#fillArc
	393	*/
	394	public void drawArc(int x, int y, int width, int height,
	395	int startAngle, int arcAngle) {
	396	draw(new Arc2D.Float(x, y, width, height,
	397	startAngle, arcAngle,
	398	Arc2D.OPEN));
	399	}
	400
	401
	402	/**
	403	* Fills a circular or elliptical arc covering the specified rectangle.
	404	* <p>
	405	* The resulting arc begins at <code>startAngle</code> and extends
	406	* for <code>arcAngle</code> degrees.
	407	* Angles are interpreted such that 0 degrees
	408	* is at the 3 o'clock position.
	409	* A positive value indicates a counter-clockwise rotation
	410	* while a negative value indicates a clockwise rotation.
	411	* <p>
	412	* The center of the arc is the center of the rectangle whose origin
	413	* is (<i>x</i>, <i>y</i>) and whose size is specified by the
	414	* <code>width</code> and <code>height</code> arguments.
	415	* <p>
	416	* The resulting arc covers an area
	417	* <code>width + 1</code> pixels wide
	418	* by <code>height + 1</code> pixels tall.
	419	* <p>
	420	* The angles are specified relative to the non-square extents of
	421	* the bounding rectangle such that 45 degrees always falls on the
	422	* line from the center of the ellipse to the upper right corner of
	423	* the bounding rectangle. As a result, if the bounding rectangle is
	424	* noticeably longer in one axis than the other, the angles to the
	425	* start and end of the arc segment will be skewed farther along the
	426	* longer axis of the bounds.
	427	* @param x the <i>x</i> coordinate of the
	428	* upper-left corner of the arc to be filled.
	429	* @param y the <i>y</i> coordinate of the
	430	* upper-left corner of the arc to be filled.
	431	* @param width the width of the arc to be filled.
	432	* @param height the height of the arc to be filled.
	433	* @param startAngle the beginning angle.
	434	* @param arcAngle the angular extent of the arc,
	435	* relative to the start angle.
	436	* @see java.awt.Graphics#drawArc
	437	*/
	438	public void fillArc(int x, int y, int width, int height,
	439	int startAngle, int arcAngle) {
	440
	441	fill(new Arc2D.Float(x, y, width, height,
	442	startAngle, arcAngle,
	443	Arc2D.PIE));
	444	}
	445
	446	/**
	447	* Draws a sequence of connected lines defined by
	448	* arrays of <i>x</i> and <i>y</i> coordinates.
	449	* Each pair of (<i>x</i>, <i>y</i>) coordinates defines a point.
	450	* The figure is not closed if the first point
	451	* differs from the last point.
	452	* @param xPoints an array of <i>x</i> points
	453	* @param yPoints an array of <i>y</i> points
	454	* @param nPoints the total number of points
	455	* @see java.awt.Graphics#drawPolygon(int[], int[], int)
	456	* @since JDK1.1
	457	*/
	458	public void drawPolyline(int xPoints[], int yPoints[],
	459	int nPoints) {
	460	float fromX;
	461	float fromY;
	462	float toX;
	463	float toY;
	464
	465	if (nPoints > 0) {
	466	fromX = xPoints[0];
	467	fromY = yPoints[0];
	468	for(int i = 1; i < nPoints; i++) {
	469	toX = xPoints[i];
	470	toY = yPoints[i];
	471	draw(new Line2D.Float(fromX, fromY, toX, toY));
	472	fromX = toX;
	473	fromY = toY;
	474	}
	475	}
	476
	477	}
	478
	479
	480	/**
	481	* Draws a closed polygon defined by
	482	* arrays of <i>x</i> and <i>y</i> coordinates.
	483	* Each pair of (<i>x</i>, <i>y</i>) coordinates defines a point.
	484	* <p>
	485	* This method draws the polygon defined by <code>nPoint</code> line
	486	* segments, where the first <code>nPoint - 1</code>
	487	* line segments are line segments from
	488	* <code>(xPoints[i - 1], yPoints[i - 1])</code>
	489	* to <code>(xPoints[i], yPoints[i])</code>, for
	490	* 1 ≤ <i>i</i> ≤ <code>nPoints</code>.
	491	* The figure is automatically closed by drawing a line connecting
	492	* the final point to the first point, if those points are different.
	493	* @param xPoints a an array of <code>x</code> coordinates.
	494	* @param yPoints a an array of <code>y</code> coordinates.
	495	* @param nPoints a the total number of points.
	496	* @see java.awt.Graphics#fillPolygon
	497	* @see java.awt.Graphics#drawPolyline
	498	*/
	499	public void drawPolygon(int xPoints[], int yPoints[],
	500	int nPoints) {
	501
	502	draw(new Polygon(xPoints, yPoints, nPoints));
	503	}
	504
	505	/**
	506	* Draws the outline of a polygon defined by the specified
	507	* <code>Polygon</code> object.
	508	* @param p the polygon to draw.
	509	* @see java.awt.Graphics#fillPolygon
	510	* @see java.awt.Graphics#drawPolyline
	511	*/
	512	public void drawPolygon(Polygon p) {
	513	draw(p);
	514	}
	515
	516	/**
	517	* Fills a closed polygon defined by
	518	* arrays of <i>x</i> and <i>y</i> coordinates.
	519	* <p>
	520	* This method draws the polygon defined by <code>nPoint</code> line
	521	* segments, where the first <code>nPoint - 1</code>
	522	* line segments are line segments from
	523	* <code>(xPoints[i - 1], yPoints[i - 1])</code>
	524	* to <code>(xPoints[i], yPoints[i])</code>, for
	525	* 1 ≤ <i>i</i> ≤ <code>nPoints</code>.
	526	* The figure is automatically closed by drawing a line connecting
	527	* the final point to the first point, if those points are different.
	528	* <p>
	529	* The area inside the polygon is defined using an
	530	* even-odd fill rule, also known as the alternating rule.
	531	* @param xPoints a an array of <code>x</code> coordinates.
	532	* @param yPoints a an array of <code>y</code> coordinates.
	533	* @param nPoints a the total number of points.
	534	* @see java.awt.Graphics#drawPolygon(int[], int[], int)
	535	*/
	536	public void fillPolygon(int xPoints[], int yPoints[],
	537	int nPoints) {
	538
	539	fill(new Polygon(xPoints, yPoints, nPoints));
	540	}
	541
	542
	543	/**
	544	* Fills the polygon defined by the specified Polygon object with
	545	* the graphics context's current color.
	546	* <p>
	547	* The area inside the polygon is defined using an
	548	* even-odd fill rule, also known as the alternating rule.
	549	* @param p the polygon to fill.
	550	* @see java.awt.Graphics#drawPolygon(int[], int[], int)
	551	*/
	552	public void fillPolygon(Polygon p) {
	553
	554	fill(p);
	555	}
	556
	557	/**
	558	* Draws the text given by the specified string, using this
	559	* graphics context's current font and color. The baseline of the
	560	* first character is at position (<i>x</i>, <i>y</i>) in this
	561	* graphics context's coordinate system.
	562	* @param str the string to be drawn.
	563	* @param x the <i>x</i> coordinate.
	564	* @param y the <i>y</i> coordinate.
	565	* @see java.awt.Graphics#drawBytes
	566	* @see java.awt.Graphics#drawChars
	567	* @since JDK1.0
	568	*/
	569	public void drawString(String str, int x, int y) {
	570	drawString(str, (float) x, (float) y);
	571	}
	572
	573	public void drawString(String str, float x, float y) {
	574	if (str.length() == 0) {
	575	return;
	576	}
	577	TextLayout layout =
	578	new TextLayout(str, getFont(), getFontRenderContext());
	579	layout.draw(this, x, y);
	580	}
	581
	582	protected void drawString(String str, float x, float y,
	583	Font font, FontRenderContext frc, float w) {
	584	TextLayout layout =
	585	new TextLayout(str, font, frc);
	586	Shape textShape =
	587	layout.getOutline(AffineTransform.getTranslateInstance(x, y));
	588	fill(textShape);
	589	}
	590
	591	/**
	592	* Draws the text given by the specified iterator, using this
	593	* graphics context's current color. The iterator has to specify a font
	594	* for each character. The baseline of the
	595	* first character is at position (<i>x</i>, <i>y</i>) in this
	596	* graphics context's coordinate system.
	597	* @param iterator the iterator whose text is to be drawn
	598	* @param x the <i>x</i> coordinate.
	599	* @param y the <i>y</i> coordinate.
	600	* @see java.awt.Graphics#drawBytes
	601	* @see java.awt.Graphics#drawChars
	602	*/
	603	public void drawString(AttributedCharacterIterator iterator,
	604	int x, int y) {
	605	drawString(iterator, (float) x, (float) y);
	606	}
	607	public void drawString(AttributedCharacterIterator iterator,
	608	float x, float y) {
	609	if (iterator == null) {
	610	throw
	611	new NullPointerException("attributedcharacteriterator is null");
	612	}
	613	TextLayout layout =
	614	new TextLayout(iterator, getFontRenderContext());
	615	layout.draw(this, x, y);
	616	}
	617
	618	/**
	619	* Draws a GlyphVector.
	620	* The rendering attributes applied include the clip, transform,
	621	* paint or color, and composite attributes. The GlyphVector specifies
	622	* individual glyphs from a Font.
	623	* @param g The GlyphVector to be drawn.
	624	* @param x,y The coordinates where the glyphs should be drawn.
	625	* @see #setPaint
	626	* @see java.awt.Graphics#setColor
	627	* @see #transform
	628	* @see #setTransform
	629	* @see #setComposite
	630	* @see #clip
	631	* @see #setClip
	632	*/
	633	public void drawGlyphVector(GlyphVector g,
	634	float x,
	635	float y) {
	636
	637	/* We should not reach here if printingGlyphVector is already true.
	638	* Add an assert so this can be tested if need be.
	639	* But also ensure that we do at least render properly by filling
	640	* the outline.
	641	*/
	642	if (printingGlyphVector) {
	643	assert !printingGlyphVector; // ie false.
	644	fill(g.getOutline(x, y));
	645	return;
	646	}
	647
	648	try {
	649	printingGlyphVector = true;
	650	if (RasterPrinterJob.shapeTextProp \|\|
	651	!printedSimpleGlyphVector(g, x, y)) {
	652	fill(g.getOutline(x, y));
	653	}
	654	} finally {
	655	printingGlyphVector = false;
	656	}
	657	}
	658
	659	protected static SoftReference<Hashtable<Font2DHandle,Object>>
	660	fontMapRef = new SoftReference<Hashtable<Font2DHandle,Object>>(null);
	661
	662	protected int platformFontCount(Font font, String str) {
	663	return 0;
	664	}
	665
	666	/**
	667	* Default implementation returns false.
	668	* Callers of this method must always be prepared for this,
	669	* and delegate to outlines or some other solution.
	670	*/
	671	protected boolean printGlyphVector(GlyphVector gv, float x, float y) {
	672	return false;
	673	}
	674
	675	/* GlyphVectors are usually encountered because TextLayout is in use.
	676	* Some times TextLayout is needed to handle complex text or some
	677	* rendering attributes trigger it.
	678	* We try to print GlyphVectors by reconstituting into a String,
	679	* as that is most recoverable for applications that export to formats
	680	* such as Postscript or PDF. In some cases (eg where its not complex
	681	* text and its just that positions aren't what we'd expect) we print
	682	* one character at a time. positioning individually.
	683	* Failing that, if we can directly send glyph codes to the printer
	684	* then we do that (printGlyphVector).
	685	* As a last resort we return false and let the caller print as filled
	686	* shapes.
	687	*/
	688	boolean printedSimpleGlyphVector(GlyphVector g, float x, float y) {
	689
	690	int flags = g.getLayoutFlags();
	691
	692	/* We can't handle RTL, re-ordering, complex glyphs etc by
	693	* reconstituting glyphs into a String. So if any flags besides
	694	* position adjustments are set, see if we can directly
	695	* print the GlyphVector as glyph codes, using the positions
	696	* layout has assigned. If that fails return false;
	697	*/
	698	if (flags != 0 && flags != GlyphVector.FLAG_HAS_POSITION_ADJUSTMENTS) {
	699	return printGlyphVector(g, x, y);
	700	}
	701
	702	Font font = g.getFont();
	703	Font2D font2D = FontUtilities.getFont2D(font);
	704	if (font2D.handle.font2D != font2D) {
	705	/* suspicious, may be a bad font. lets bail */
	706	return false;
	707	}
	708	Hashtable<Font2DHandle,Object> fontMap;
	709	synchronized (PathGraphics.class) {
	710	fontMap = fontMapRef.get();
	711	if (fontMap == null) {
	712	fontMap = new Hashtable<Font2DHandle,Object>();
	713	fontMapRef =
	714	new SoftReference<Hashtable<Font2DHandle,Object>>(fontMap);
	715	}
	716	}
	717
	718	int numGlyphs = g.getNumGlyphs();
	719	int[] glyphCodes = g.getGlyphCodes(0, numGlyphs, null);
	720
	721	char[] glyphToCharMap = null;
	722	char[][] mapArray = null;
	723	CompositeFont cf = null;
	724
	725	/* Build the needed maps for this font in a synchronized block */
	726	synchronized (fontMap) {
	727	if (font2D instanceof CompositeFont) {
	728	cf = (CompositeFont)font2D;
	729	int numSlots = cf.getNumSlots();
	730	mapArray = (char[][])fontMap.get(font2D.handle);
	731	if (mapArray == null) {
	732	mapArray = new char[numSlots][];
	733	fontMap.put(font2D.handle, mapArray);
	734	}
	735	for (int i=0; i<numGlyphs;i++) {
	736	int slot = glyphCodes[i] >>> 24;
	737	if (slot >= numSlots) { /* shouldn't happen */
	738	return false;
	739	}
	740	if (mapArray[slot] == null) {
	741	Font2D slotFont = cf.getSlotFont(slot);
	742	char[] map = (char[])fontMap.get(slotFont.handle);
	743	if (map == null) {
	744	map = getGlyphToCharMapForFont(slotFont);
	745	}
	746	mapArray[slot] = map;
	747	}
	748	}
	749	} else {
	750	glyphToCharMap = (char[])fontMap.get(font2D.handle);
	751	if (glyphToCharMap == null) {
	752	glyphToCharMap = getGlyphToCharMapForFont(font2D);
	753	fontMap.put(font2D.handle, glyphToCharMap);
	754	}
	755	}
	756	}
	757
	758	char[] chars = new char[numGlyphs];
	759	if (cf != null) {
	760	for (int i=0; i<numGlyphs; i++) {
	761	int gc = glyphCodes[i];
	762	char[] map = mapArray[gc >>> 24];
	763	gc = gc & 0xffffff;
	764	if (map == null) {
	765	return false;
	766	}
	767	/* X11 symbol & dingbats fonts used only for global metrics,
	768	* so the glyph codes we have really refer to Lucida Sans
	769	* Regular.
	770	* So its possible the glyph code may appear out of range.
	771	* Note that later on we double-check the glyph codes that
	772	* we get from re-creating the GV from the string are the
	773	* same as those we started with.
	774	*
	775	* If the glyphcode is INVISIBLE_GLYPH_ID then this may
	776	* be \t, \n or \r which are mapped to that by layout.
	777	* This is a case we can handle. It doesn't matter what
	778	* character we use (we use \n) so long as layout maps it
	779	* back to this in the verification, since the invisible
	780	* glyph isn't visible :)
	781	*/
	782	char ch;
	783	if (gc == CharToGlyphMapper.INVISIBLE_GLYPH_ID) {
	784	ch = '\n';
	785	} else if (gc < 0 \|\| gc >= map.length) {
	786	return false;
	787	} else {
	788	ch = map[gc];
	789	}
	790	if (ch != CharToGlyphMapper.INVISIBLE_GLYPH_ID) {
	791	chars[i] = ch;
	792	} else {
	793	return false;
	794	}
	795	}
	796	} else {
	797	for (int i=0; i<numGlyphs; i++) {
	798	int gc = glyphCodes[i];
	799	char ch;
	800	if (gc == CharToGlyphMapper.INVISIBLE_GLYPH_ID) {
	801	ch = '\n';
	802	} else if (gc < 0 \|\| gc >= glyphToCharMap.length) {
	803	return false;
	804	} else {
	805	ch = glyphToCharMap[gc];
	806	}
	807	if (ch != CharToGlyphMapper.INVISIBLE_GLYPH_ID) {
	808	chars[i] = ch;
	809	} else {
	810	return false;
	811	}
	812	}
	813	}
	814
	815	FontRenderContext gvFrc = g.getFontRenderContext();
	816	GlyphVector gv2 = font.createGlyphVector(gvFrc, chars);
	817	if (gv2.getNumGlyphs() != numGlyphs) {
	818	return printGlyphVector(g, x, y);
	819	}
	820	int[] glyphCodes2 = gv2.getGlyphCodes(0, numGlyphs, null);
	821	/*
	822	* Needed to double-check remapping of X11 symbol & dingbats.
	823	*/
	824	for (int i=0; i<numGlyphs; i++) {
	825	if (glyphCodes[i] != glyphCodes2[i]) {
	826	return printGlyphVector(g, x, y);
	827	}
	828	}
	829
	830	FontRenderContext g2dFrc = getFontRenderContext();
	831	boolean compatibleFRC = gvFrc.equals(g2dFrc);
	832	/* If differ only in specifying A-A or a translation, these are
	833	* also compatible FRC's, and we can do one drawString call.
	834	*/
	835	if (!compatibleFRC &&
	836	gvFrc.usesFractionalMetrics() == g2dFrc.usesFractionalMetrics()) {
	837	AffineTransform gvAT = gvFrc.getTransform();
	838	AffineTransform g2dAT = getTransform();
	839	double[] gvMatrix = new double[4];
	840	double[] g2dMatrix = new double[4];
	841	gvAT.getMatrix(gvMatrix);
	842	g2dAT.getMatrix(g2dMatrix);
	843	compatibleFRC = true;
	844	for (int i=0;i<4;i++) {
	845	if (gvMatrix[i] != g2dMatrix[i]) {
	846	compatibleFRC = false;
	847	break;
	848	}
	849	}
	850	}
	851
	852	String str = new String(chars, 0, numGlyphs);
	853	int numFonts = platformFontCount(font, str);
	854	if (numFonts == 0) {
	855	return false;
	856	}
	857
	858	float[] positions = g.getGlyphPositions(0, numGlyphs, null);
	859	boolean noPositionAdjustments =
	860	((flags & GlyphVector.FLAG_HAS_POSITION_ADJUSTMENTS) == 0) \|\|
	861	samePositions(gv2, glyphCodes2, glyphCodes, positions);
	862
	863	/* We have to consider that the application may be directly
	864	* creating a GlyphVector, rather than one being created by
	865	* TextLayout or indirectly from drawString. In such a case, if the
	866	* font has layout attributes, the text may measure differently
	867	* when we reconstitute it into a String and ask for the length that
	868	* drawString would use. For example, KERNING will be applied in such
	869	* a case but that Font attribute is not applied when the application
	870	* directly created a GlyphVector. So in this case we need to verify
	871	* that the text measures the same in both cases - ie that the
	872	* layout attribute has no effect. If it does we can't always
	873	* use the drawString call unless we can coerce the drawString call
	874	* into measuring and displaying the string to the same length.
	875	* That is the case where there is only one font used and we can
	876	* specify the overall advance of the string. (See below).
	877	*/
	878
	879	Point2D gvAdvancePt = g.getGlyphPosition(numGlyphs);
	880	float gvAdvanceX = (float)gvAdvancePt.getX();
	881	boolean layoutAffectsAdvance = false;
	882	if (font.hasLayoutAttributes() && printingGlyphVector &&
	883	noPositionAdjustments) {
	884
	885	/* If TRACKING is in use then the glyph vector will report
	886	* position adjustments, then that ought to be sufficient to
	887	* tell us we can't just ask native to do "drawString". But layout
	888	* always sets the position adjustment flag, so we don't believe
	889	* it and verify the positions are really different than
	890	* createGlyphVector() (with no layout) would create. However
	891	* inconsistently, TRACKING is applied when creating a GlyphVector,
	892	* since it doesn't actually require "layout" (even though its
	893	* considered a layout attribute), it just requires a fractional
	894	* tweak to the[default]advances. So we need to specifically
	895	* check for tracking until such time as as we can trust
	896	* the GlyphVector.FLAG_HAS_POSITION_ADJUSTMENTS bit.
	897	*/
	898	Map<TextAttribute, ?> map = font.getAttributes();
	899	Object o = map.get(TextAttribute.TRACKING);
	900	boolean tracking = o != null && (o instanceof Number) &&
	901	(((Number)o).floatValue() != 0f);
	902
	903	if (tracking) {
	904	noPositionAdjustments = false;
	905	} else {
	906	Rectangle2D bounds = font.getStringBounds(str, gvFrc);
	907	float strAdvanceX = (float)bounds.getWidth();
	908	if (Math.abs(strAdvanceX - gvAdvanceX) > 0.00001) {
	909	layoutAffectsAdvance = true;
	910	}
	911	}
	912	}
	913
	914	if (compatibleFRC && noPositionAdjustments && !layoutAffectsAdvance) {
	915	drawString(str, x, y, font, gvFrc, 0f);
	916	return true;
	917	}
	918
	919	/* If positions have not been explicitly assigned, we can
	920	* ask the string to be drawn adjusted to this width.
	921	* This call is supported only in the PS generator.
	922	* GDI has API to specify the advance for each glyph in a
	923	* string which could be used here too, but that is not yet
	924	* implemented, and we'd need to update the signature of the
	925	* drawString method to take the advances (ie relative positions)
	926	* and use that instead of the width.
	927	*/
	928	if (numFonts == 1 && canDrawStringToWidth() && noPositionAdjustments) {
	929	drawString(str, x, y, font, gvFrc, gvAdvanceX);
	930	return true;
	931	}
	932
	933	/* In some scripts chars drawn individually do not have the
	934	* same representation (glyphs) as when combined with other chars.
	935	* The logic here is erring on the side of caution, in particular
	936	* in including supplementary characters.
	937	*/
	938	if (FontUtilities.isComplexText(chars, 0, chars.length)) {
	939	return printGlyphVector(g, x, y);
	940	}
	941
	942	/* If we reach here we have mapped all the glyphs back
	943	* one-to-one to simple unicode chars that we know are in the font.
	944	* We can call "drawChars" on each one of them in turn, setting
	945	* the position based on the glyph positions.
	946	* There's typically overhead in this. If numGlyphs is 'large',
	947	* it may even be better to try printGlyphVector() in this case.
	948	* This may be less recoverable for apps, but sophisticated apps
	949	* should be able to recover the text from simple glyph vectors
	950	* and we can avoid penalising the more common case - although
	951	* this is already a minority case.
	952	*/
	953	if (numGlyphs > 10 && printGlyphVector(g, x, y)) {
	954	return true;
	955	}
	956
	957	for (int i=0; i<numGlyphs; i++) {
	958	String s = new String(chars, i, 1);
	959	drawString(s, x+positions[i2], y+positions[i2+1],
	960	font, gvFrc, 0f);
	961	}
	962	return true;
	963	}
	964
	965	/* The same codes must be in the same positions for this to return true.
	966	* This would look cleaner if it took the original GV as a parameter but
	967	* we already have the codes and will need to get the positions array
	968	* too in most cases anyway. So its cheaper to pass them in.
	969	* This call wouldn't be necessary if layout didn't always set the
	970	* FLAG_HAS_POSITION_ADJUSTMENTS even if the default advances are used
	971	* and there was no re-ordering (this should be fixed some day).
	972	*/
	973	private boolean samePositions(GlyphVector gv, int[] gvcodes,
	974	int[] origCodes, float[] origPositions) {
	975
	976	int numGlyphs = gv.getNumGlyphs();
	977	float[] gvpos = gv.getGlyphPositions(0, numGlyphs, null);
	978
	979	/* this shouldn't happen here, but just in case */
	980	if (numGlyphs != gvcodes.length \|\| /* real paranoia here */
	981	origCodes.length != gvcodes.length \|\|
	982	origPositions.length != gvpos.length) {
	983	return false;
	984	}
	985
	986	for (int i=0; i<numGlyphs; i++) {
	987	if (gvcodes[i] != origCodes[i] \|\| gvpos[i] != origPositions[i]) {
	988	return false;
	989	}
	990	}
	991	return true;
	992	}
	993
	994	protected boolean canDrawStringToWidth() {
	995	return false;
	996	}
	997
	998	/* return an array which can map glyphs back to char codes.
	999	* Glyphs which aren't mapped from a simple unicode code point
	1000	* will have no mapping in this array, and will be assumed to be
	1001	* because of some substitution that we can't handle.
	1002	*/
	1003	private static char[] getGlyphToCharMapForFont(Font2D font2D) {
	1004	/* NB Composites report the number of glyphs in slot 0.
	1005	* So if a string uses a char from a later slot, or a fallback slot,
	1006	* it will not be able to use this faster path.
	1007	*/
	1008	int numGlyphs = font2D.getNumGlyphs();
	1009	int missingGlyph = font2D.getMissingGlyphCode();
	1010	char[] glyphToCharMap = new char[numGlyphs];
	1011	int glyph;
	1012
	1013	for (int i=0;i<numGlyphs; i++) {
	1014	glyphToCharMap[i] = CharToGlyphMapper.INVISIBLE_GLYPH_ID;
	1015	}
	1016
	1017	/* Consider refining the ranges to try to map by asking the font
	1018	* what ranges it supports.
	1019	* Since a glyph may be mapped by multiple code points, and this
	1020	* code can't handle that, we always prefer the earlier code point.
	1021	*/
	1022	for (char c=0; c<0xFFFF; c++) {
	1023	if (c >= CharToGlyphMapper.HI_SURROGATE_START &&
	1024	c <= CharToGlyphMapper.LO_SURROGATE_END) {
	1025	continue;
	1026	}
	1027	glyph = font2D.charToGlyph(c);
	1028	if (glyph != missingGlyph && glyph < numGlyphs &&
	1029	(glyphToCharMap[glyph] ==
	1030	CharToGlyphMapper.INVISIBLE_GLYPH_ID)) {
	1031	glyphToCharMap[glyph] = c;
	1032	}
	1033	}
	1034	return glyphToCharMap;
	1035	}
	1036
	1037	/**
	1038	* Strokes the outline of a Shape using the settings of the current
	1039	* graphics state. The rendering attributes applied include the
	1040	* clip, transform, paint or color, composite and stroke attributes.
	1041	* @param s The shape to be drawn.
	1042	* @see #setStroke
	1043	* @see #setPaint
	1044	* @see java.awt.Graphics#setColor
	1045	* @see #transform
	1046	* @see #setTransform
	1047	* @see #clip
	1048	* @see #setClip
	1049	* @see #setComposite
	1050	*/
	1051	public void draw(Shape s) {
	1052
	1053	fill(getStroke().createStrokedShape(s));
	1054	}
	1055
	1056	/**
	1057	* Fills the interior of a Shape using the settings of the current
	1058	* graphics state. The rendering attributes applied include the
	1059	* clip, transform, paint or color, and composite.
	1060	* @see #setPaint
	1061	* @see java.awt.Graphics#setColor
	1062	* @see #transform
	1063	* @see #setTransform
	1064	* @see #setComposite
	1065	* @see #clip
	1066	* @see #setClip
	1067	*/
	1068	public void fill(Shape s) {
	1069	Paint paint = getPaint();
	1070
	1071	try {
	1072	fill(s, (Color) paint);
	1073
	1074	/* The PathGraphics class only supports filling with
	1075	* solid colors and so we do not expect the cast of Paint
	1076	* to Color to fail. If it does fail then something went
	1077	* wrong, like the app draw a page with a solid color but
	1078	* then redrew it with a Gradient.
	1079	*/
	1080	} catch (ClassCastException e) {
	1081	throw new IllegalArgumentException("Expected a Color instance");
	1082	}
	1083	}
	1084
	1085	public void fill(Shape s, Color color) {
	1086	AffineTransform deviceTransform = getTransform();
	1087
	1088	if (getClip() != null) {
	1089	deviceClip(getClip().getPathIterator(deviceTransform));
	1090	}
	1091	deviceFill(s.getPathIterator(deviceTransform), color);
	1092	}
	1093
	1094	/**
	1095	* Fill the path defined by <code>pathIter</code>
	1096	* with the specified color.
	1097	* The path is provided in device coordinates.
	1098	*/
	1099	protected abstract void deviceFill(PathIterator pathIter, Color color);
	1100
	1101	/*
	1102	* Set the clipping path to that defined by
	1103	* the passed in <code>PathIterator</code>.
	1104	*/
	1105	protected abstract void deviceClip(PathIterator pathIter);
	1106
	1107	/*
	1108	* Draw the outline of the rectangle without using path
	1109	* if supported by platform.
	1110	*/
	1111	protected abstract void deviceFrameRect(int x, int y,
	1112	int width, int height,
	1113	Color color);
	1114
	1115	/*
	1116	* Draw a line without using path if supported by platform.
	1117	*/
	1118	protected abstract void deviceDrawLine(int xBegin, int yBegin,
	1119	int xEnd, int yEnd, Color color);
	1120
	1121	/*
	1122	* Fill a rectangle using specified color.
	1123	*/
	1124	protected abstract void deviceFillRect(int x, int y,
	1125	int width, int height, Color color);
	1126
	1127	/* Obtain a BI from known implementations of java.awt.Image
	1128	*/
	1129	protected BufferedImage getBufferedImage(Image img) {
	1130	if (img instanceof BufferedImage) {
	1131	// Otherwise we expect a BufferedImage to behave as a standard BI
	1132	return (BufferedImage)img;
	1133	} else if (img instanceof ToolkitImage) {
	1134	// This can be null if the image isn't loaded yet.
	1135	// This is fine as in that case our caller will return
	1136	// as it will only draw a fully loaded image
	1137	return ((ToolkitImage)img).getBufferedImage();
	1138	} else if (img instanceof VolatileImage) {
	1139	// VI needs to make a new BI: this is unavoidable but
	1140	// I don't expect VI's to be "huge" in any case.
	1141	return ((VolatileImage)img).getSnapshot();
	1142	} else {
	1143	// may be null or may be some non-standard Image which
	1144	// shouldn't happen as Image is implemented by the platform
	1145	// not by applications
	1146	// If you add a new Image implementation to the platform you
	1147	// will need to support it here similarly to VI.
	1148	return null;
	1149	}
	1150	}
	1151
	1152	/**
	1153	* Return true if the BufferedImage argument has non-opaque
	1154	* bits in it and therefore can not be directly rendered by
	1155	* GDI. Return false if the image is opaque. If this function
	1156	* can not tell for sure whether the image has transparent
	1157	* pixels then it assumes that it does.
	1158	*/
	1159	protected boolean hasTransparentPixels(BufferedImage bufferedImage) {
	1160	ColorModel colorModel = bufferedImage.getColorModel();
	1161	boolean hasTransparency = colorModel == null
	1162	? true
	1163	: colorModel.getTransparency() != ColorModel.OPAQUE;
	1164
	1165	/*
	1166	* For the default INT ARGB check the image to see if any pixels are
	1167	* really transparent. If there are no transparent pixels then the
	1168	* transparency of the color model can be ignored.
	1169	* We assume that IndexColorModel images have already been
	1170	* checked for transparency and will be OPAQUE unless they actually
	1171	* have transparent pixels present.
	1172	*/
	1173	if (hasTransparency && bufferedImage != null) {
	1174	if (bufferedImage.getType()==BufferedImage.TYPE_INT_ARGB \|\|
	1175	bufferedImage.getType()==BufferedImage.TYPE_INT_ARGB_PRE) {
	1176	DataBuffer db = bufferedImage.getRaster().getDataBuffer();
	1177	SampleModel sm = bufferedImage.getRaster().getSampleModel();
	1178	if (db instanceof DataBufferInt &&
	1179	sm instanceof SinglePixelPackedSampleModel) {
	1180	SinglePixelPackedSampleModel psm =
	1181	(SinglePixelPackedSampleModel)sm;
	1182	// Stealing the data array for reading only...
	1183	int[] int_data =
	1184	SunWritableRaster.stealData((DataBufferInt) db, 0);
	1185	int x = bufferedImage.getMinX();
	1186	int y = bufferedImage.getMinY();
	1187	int w = bufferedImage.getWidth();
	1188	int h = bufferedImage.getHeight();
	1189	int stride = psm.getScanlineStride();
	1190	boolean hastranspixel = false;
	1191	for (int j = y; j < y+h; j++) {
	1192	int yoff = j * stride;
	1193	for (int i = x; i < x+w; i++) {
	1194	if ((int_data[yoff+i] & 0xff000000)!=0xff000000 ) {
	1195	hastranspixel = true;
	1196	break;
	1197	}
	1198	}
	1199	if (hastranspixel) {
	1200	break;
	1201	}
	1202	}
	1203	if (hastranspixel == false) {
	1204	hasTransparency = false;
	1205	}
	1206	}
	1207	}
	1208	}
	1209
	1210	return hasTransparency;
	1211	}
	1212
	1213	protected boolean isBitmaskTransparency(BufferedImage bufferedImage) {
	1214	ColorModel colorModel = bufferedImage.getColorModel();
	1215	return (colorModel != null &&
	1216	colorModel.getTransparency() == ColorModel.BITMASK);
	1217	}
	1218
	1219
	1220	/* An optimisation for the special case of ICM images which have
	1221	* bitmask transparency.
	1222	*/
	1223	protected boolean drawBitmaskImage(BufferedImage bufferedImage,
	1224	AffineTransform xform,
	1225	Color bgcolor,
	1226	int srcX, int srcY,
	1227	int srcWidth, int srcHeight) {
	1228
	1229	ColorModel colorModel = bufferedImage.getColorModel();
	1230	IndexColorModel icm;
	1231	int [] pixels;
	1232
	1233	if (!(colorModel instanceof IndexColorModel)) {
	1234	return false;
	1235	} else {
	1236	icm = (IndexColorModel)colorModel;
	1237	}
	1238
	1239	if (colorModel.getTransparency() != ColorModel.BITMASK) {
	1240	return false;
	1241	}
	1242
	1243	// to be compatible with 1.1 printing which treated b/g colors
	1244	// with alpha 128 as opaque
	1245	if (bgcolor != null && bgcolor.getAlpha() < 128) {
	1246	return false;
	1247	}
	1248
	1249	if ((xform.getType()
	1250	& ~( AffineTransform.TYPE_UNIFORM_SCALE
	1251	\| AffineTransform.TYPE_TRANSLATION
	1252	\| AffineTransform.TYPE_QUADRANT_ROTATION
	1253	)) != 0) {
	1254	return false;
	1255	}
	1256
	1257	if ((getTransform().getType()
	1258	& ~( AffineTransform.TYPE_UNIFORM_SCALE
	1259	\| AffineTransform.TYPE_TRANSLATION
	1260	\| AffineTransform.TYPE_QUADRANT_ROTATION
	1261	)) != 0) {
	1262	return false;
	1263	}
	1264
	1265	BufferedImage subImage = null;
	1266	Raster raster = bufferedImage.getRaster();
	1267	int transpixel = icm.getTransparentPixel();
	1268	byte[] alphas = new byte[icm.getMapSize()];
	1269	icm.getAlphas(alphas);
	1270	if (transpixel >= 0) {
	1271	alphas[transpixel] = 0;
	1272	}
	1273
	1274	/* don't just use srcWidth & srcHeight from application - they
	1275	* may exceed the extent of the image - may need to clip.
	1276	* The image xform will ensure that points are still mapped properly.
	1277	*/
	1278	int rw = raster.getWidth();
	1279	int rh = raster.getHeight();
	1280	if (srcX > rw \|\| srcY > rh) {
	1281	return false;
	1282	}
	1283	int right, bottom, wid, hgt;
	1284	if (srcX+srcWidth > rw) {
	1285	right = rw;
	1286	wid = right - srcX;
	1287	} else {
	1288	right = srcX+srcWidth;
	1289	wid = srcWidth;
	1290	}
	1291	if (srcY+srcHeight > rh) {
	1292	bottom = rh;
	1293	hgt = bottom - srcY;
	1294	} else {
	1295	bottom = srcY+srcHeight;
	1296	hgt = srcHeight;
	1297	}
	1298	pixels = new int[wid];
	1299	for (int j=srcY; j<bottom; j++) {
	1300	int startx = -1;
	1301	raster.getPixels(srcX, j, wid, 1, pixels);
	1302	for (int i=srcX; i<right; i++) {
	1303	if (alphas[pixels[i-srcX]] == 0) {
	1304	if (startx >=0) {
	1305	subImage = bufferedImage.getSubimage(startx, j,
	1306	i-startx, 1);
	1307	xform.translate(startx, j);
	1308	drawImageToPlatform(subImage, xform, bgcolor,
	1309	0, 0, i-startx, 1, true);
	1310	xform.translate(-startx, -j);
	1311	startx = -1;
	1312	}
	1313	} else if (startx < 0) {
	1314	startx = i;
	1315	}
	1316	}
	1317	if (startx >= 0) {
	1318	subImage = bufferedImage.getSubimage(startx, j,
	1319	right - startx, 1);
	1320	xform.translate(startx, j);
	1321	drawImageToPlatform(subImage, xform, bgcolor,
	1322	0, 0, right - startx, 1, true);
	1323	xform.translate(-startx, -j);
	1324	}
	1325	}
	1326	return true;
	1327	}
	1328
	1329
	1330
	1331	/**
	1332	* The various <code>drawImage()</code> methods for
	1333	* <code>PathGraphics</code> are all decomposed
	1334	* into an invocation of <code>drawImageToPlatform</code>.
	1335	* The portion of the passed in image defined by
	1336	* <code>srcX, srcY, srcWidth, and srcHeight</code>
	1337	* is transformed by the supplied AffineTransform and
	1338	* drawn using PS to the printer context.
	1339	*
	1340	* @param img The image to be drawn.
	1341	* This method does nothing if <code>img</code> is null.
	1342	* @param xform Used to tranform the image before drawing.
	1343	* This can be null.
	1344	* @param bgcolor This color is drawn where the image has transparent
	1345	* pixels. If this parameter is null then the
	1346	* pixels already in the destination should show
	1347	* through.
	1348	* @param srcX With srcY this defines the upper-left corner
	1349	* of the portion of the image to be drawn.
	1350	*
	1351	* @param srcY With srcX this defines the upper-left corner
	1352	* of the portion of the image to be drawn.
	1353	* @param srcWidth The width of the portion of the image to
	1354	* be drawn.
	1355	* @param srcHeight The height of the portion of the image to
	1356	* be drawn.
	1357	* @param handlingTransparency if being recursively called to
	1358	* print opaque region of transparent image
	1359	*/
	1360	protected abstract boolean
	1361	drawImageToPlatform(Image img, AffineTransform xform,
	1362	Color bgcolor,
	1363	int srcX, int srcY,
	1364	int srcWidth, int srcHeight,
	1365	boolean handlingTransparency);
	1366
	1367	/**
	1368	* Draws as much of the specified image as is currently available.
	1369	* The image is drawn with its top-left corner at
	1370	* (<i>x</i>, <i>y</i>) in this graphics context's coordinate
	1371	* space. Transparent pixels in the image do not affect whatever
	1372	* pixels are already there.
	1373	* <p>
	1374	* This method returns immediately in all cases, even if the
	1375	* complete image has not yet been loaded, and it has not been dithered
	1376	* and converted for the current output device.
	1377	* <p>
	1378	* If the image has not yet been completely loaded, then
	1379	* <code>drawImage</code> returns <code>false</code>. As more of
	1380	* the image becomes available, the process that draws the image notifies
	1381	* the specified image observer.
	1382	* @param img the specified image to be drawn.
	1383	* @param x the <i>x</i> coordinate.
	1384	* @param y the <i>y</i> coordinate.
	1385	* @param observer object to be notified as more of
	1386	* the image is converted.
	1387	* @see java.awt.Image
	1388	* @see java.awt.image.ImageObserver
	1389	* @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
	1390	* @since JDK1.0
	1391	*/
	1392	public boolean drawImage(Image img, int x, int y,
	1393	ImageObserver observer) {
	1394
	1395	return drawImage(img, x, y, null, observer);
	1396	}
	1397
	1398	/**
	1399	* Draws as much of the specified image as has already been scaled
	1400	* to fit inside the specified rectangle.
	1401	* <p>
	1402	* The image is drawn inside the specified rectangle of this
	1403	* graphics context's coordinate space, and is scaled if
	1404	* necessary. Transparent pixels do not affect whatever pixels
	1405	* are already there.
	1406	* <p>
	1407	* This method returns immediately in all cases, even if the
	1408	* entire image has not yet been scaled, dithered, and converted
	1409	* for the current output device.
	1410	* If the current output representation is not yet complete, then
	1411	* <code>drawImage</code> returns <code>false</code>. As more of
	1412	* the image becomes available, the process that draws the image notifies
	1413	* the image observer by calling its <code>imageUpdate</code> method.
	1414	* <p>
	1415	* A scaled version of an image will not necessarily be
	1416	* available immediately just because an unscaled version of the
	1417	* image has been constructed for this output device. Each size of
	1418	* the image may be cached separately and generated from the original
	1419	* data in a separate image production sequence.
	1420	* @param img the specified image to be drawn.
	1421	* @param x the <i>x</i> coordinate.
	1422	* @param y the <i>y</i> coordinate.
	1423	* @param width the width of the rectangle.
	1424	* @param height the height of the rectangle.
	1425	* @param observer object to be notified as more of
	1426	* the image is converted.
	1427	* @see java.awt.Image
	1428	* @see java.awt.image.ImageObserver
	1429	* @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
	1430	* @since JDK1.0
	1431	*/
	1432	public boolean drawImage(Image img, int x, int y,
	1433	int width, int height,
	1434	ImageObserver observer) {
	1435
	1436	return drawImage(img, x, y, width, height, null, observer);
	1437
	1438	}
	1439
	1440	/*
	1441	* Draws as much of the specified image as is currently available.
	1442	* The image is drawn with its top-left corner at
	1443	* (<i>x</i>, <i>y</i>) in this graphics context's coordinate
	1444	* space. Transparent pixels are drawn in the specified
	1445	* background color.
	1446	* <p>
	1447	* This operation is equivalent to filling a rectangle of the
	1448	* width and height of the specified image with the given color and then
	1449	* drawing the image on top of it, but possibly more efficient.
	1450	* <p>
	1451	* This method returns immediately in all cases, even if the
	1452	* complete image has not yet been loaded, and it has not been dithered
	1453	* and converted for the current output device.
	1454	* <p>
	1455	* If the image has not yet been completely loaded, then
	1456	* <code>drawImage</code> returns <code>false</code>. As more of
	1457	* the image becomes available, the process that draws the image notifies
	1458	* the specified image observer.
	1459	* @param img the specified image to be drawn.
	1460	* This method does nothing if <code>img</code> is null.
	1461	* @param x the <i>x</i> coordinate.
	1462	* @param y the <i>y</i> coordinate.
	1463	* @param bgcolor the background color to paint under the
	1464	* non-opaque portions of the image.
	1465	* In this WPathGraphics implementation,
	1466	* this parameter can be null in which
	1467	* case that background is made a transparent
	1468	* white.
	1469	* @param observer object to be notified as more of
	1470	* the image is converted.
	1471	* @see java.awt.Image
	1472	* @see java.awt.image.ImageObserver
	1473	* @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
	1474	* @since JDK1.0
	1475	*/
	1476	public boolean drawImage(Image img, int x, int y,
	1477	Color bgcolor,
	1478	ImageObserver observer) {
	1479
	1480	if (img == null) {
	1481	return true;
	1482	}
	1483
	1484	boolean result;
	1485	int srcWidth = img.getWidth(null);
	1486	int srcHeight = img.getHeight(null);
	1487
	1488	if (srcWidth < 0 \|\| srcHeight < 0) {
	1489	result = false;
	1490	} else {
	1491	result = drawImage(img, x, y, srcWidth, srcHeight, bgcolor, observer);
	1492	}
	1493
	1494	return result;
	1495	}
	1496
	1497	/**
	1498	* Draws as much of the specified image as has already been scaled
	1499	* to fit inside the specified rectangle.
	1500	* <p>
	1501	* The image is drawn inside the specified rectangle of this
	1502	* graphics context's coordinate space, and is scaled if
	1503	* necessary. Transparent pixels are drawn in the specified
	1504	* background color.
	1505	* This operation is equivalent to filling a rectangle of the
	1506	* width and height of the specified image with the given color and then
	1507	* drawing the image on top of it, but possibly more efficient.
	1508	* <p>
	1509	* This method returns immediately in all cases, even if the
	1510	* entire image has not yet been scaled, dithered, and converted
	1511	* for the current output device.
	1512	* If the current output representation is not yet complete then
	1513	* <code>drawImage</code> returns <code>false</code>. As more of
	1514	* the image becomes available, the process that draws the image notifies
	1515	* the specified image observer.
	1516	* <p>
	1517	* A scaled version of an image will not necessarily be
	1518	* available immediately just because an unscaled version of the
	1519	* image has been constructed for this output device. Each size of
	1520	* the image may be cached separately and generated from the original
	1521	* data in a separate image production sequence.
	1522	* @param img the specified image to be drawn.
	1523	* This method does nothing if <code>img</code> is null.
	1524	* @param x the <i>x</i> coordinate.
	1525	* @param y the <i>y</i> coordinate.
	1526	* @param width the width of the rectangle.
	1527	* @param height the height of the rectangle.
	1528	* @param bgcolor the background color to paint under the
	1529	* non-opaque portions of the image.
	1530	* @param observer object to be notified as more of
	1531	* the image is converted.
	1532	* @see java.awt.Image
	1533	* @see java.awt.image.ImageObserver
	1534	* @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
	1535	* @since JDK1.0
	1536	*/
	1537	public boolean drawImage(Image img, int x, int y,
	1538	int width, int height,
	1539	Color bgcolor,
	1540	ImageObserver observer) {
	1541
	1542	if (img == null) {
	1543	return true;
	1544	}
	1545
	1546	boolean result;
	1547	int srcWidth = img.getWidth(null);
	1548	int srcHeight = img.getHeight(null);
	1549
	1550	if (srcWidth < 0 \|\| srcHeight < 0) {
	1551	result = false;
	1552	} else {
	1553	result = drawImage(img,
	1554	x, y, x + width, y + height,
	1555	0, 0, srcWidth, srcHeight,
	1556	observer);
	1557	}
	1558
	1559	return result;
	1560	}
	1561
	1562	/**
	1563	* Draws as much of the specified area of the specified image as is
	1564	* currently available, scaling it on the fly to fit inside the
	1565	* specified area of the destination drawable surface. Transparent pixels
	1566	* do not affect whatever pixels are already there.
	1567	* <p>
	1568	* This method returns immediately in all cases, even if the
	1569	* image area to be drawn has not yet been scaled, dithered, and converted
	1570	* for the current output device.
	1571	* If the current output representation is not yet complete then
	1572	* <code>drawImage</code> returns <code>false</code>. As more of
	1573	* the image becomes available, the process that draws the image notifies
	1574	* the specified image observer.
	1575	* <p>
	1576	* This method always uses the unscaled version of the image
	1577	* to render the scaled rectangle and performs the required
	1578	* scaling on the fly. It does not use a cached, scaled version
	1579	* of the image for this operation. Scaling of the image from source
	1580	* to destination is performed such that the first coordinate
	1581	* of the source rectangle is mapped to the first coordinate of
	1582	* the destination rectangle, and the second source coordinate is
	1583	* mapped to the second destination coordinate. The subimage is
	1584	* scaled and flipped as needed to preserve those mappings.
	1585	* @param img the specified image to be drawn
	1586	* @param dx1 the <i>x</i> coordinate of the first corner of the
	1587	* destination rectangle.
	1588	* @param dy1 the <i>y</i> coordinate of the first corner of the
	1589	* destination rectangle.
	1590	* @param dx2 the <i>x</i> coordinate of the second corner of the
	1591	* destination rectangle.
	1592	* @param dy2 the <i>y</i> coordinate of the second corner of the
	1593	* destination rectangle.
	1594	* @param sx1 the <i>x</i> coordinate of the first corner of the
	1595	* source rectangle.
	1596	* @param sy1 the <i>y</i> coordinate of the first corner of the
	1597	* source rectangle.
	1598	* @param sx2 the <i>x</i> coordinate of the second corner of the
	1599	* source rectangle.
	1600	* @param sy2 the <i>y</i> coordinate of the second corner of the
	1601	* source rectangle.
	1602	* @param observer object to be notified as more of the image is
	1603	* scaled and converted.
	1604	* @see java.awt.Image
	1605	* @see java.awt.image.ImageObserver
	1606	* @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
	1607	* @since JDK1.1
	1608	*/
	1609	public boolean drawImage(Image img,
	1610	int dx1, int dy1, int dx2, int dy2,
	1611	int sx1, int sy1, int sx2, int sy2,
	1612	ImageObserver observer) {
	1613
	1614	return drawImage(img,
	1615	dx1, dy1, dx2, dy2,
	1616	sx1, sy1, sx2, sy2,
	1617	null, observer);
	1618	}
	1619
	1620	/**
	1621	* Draws as much of the specified area of the specified image as is
	1622	* currently available, scaling it on the fly to fit inside the
	1623	* specified area of the destination drawable surface.
	1624	* <p>
	1625	* Transparent pixels are drawn in the specified background color.
	1626	* This operation is equivalent to filling a rectangle of the
	1627	* width and height of the specified image with the given color and then
	1628	* drawing the image on top of it, but possibly more efficient.
	1629	* <p>
	1630	* This method returns immediately in all cases, even if the
	1631	* image area to be drawn has not yet been scaled, dithered, and converted
	1632	* for the current output device.
	1633	* If the current output representation is not yet complete then
	1634	* <code>drawImage</code> returns <code>false</code>. As more of
	1635	* the image becomes available, the process that draws the image notifies
	1636	* the specified image observer.
	1637	* <p>
	1638	* This method always uses the unscaled version of the image
	1639	* to render the scaled rectangle and performs the required
	1640	* scaling on the fly. It does not use a cached, scaled version
	1641	* of the image for this operation. Scaling of the image from source
	1642	* to destination is performed such that the first coordinate
	1643	* of the source rectangle is mapped to the first coordinate of
	1644	* the destination rectangle, and the second source coordinate is
	1645	* mapped to the second destination coordinate. The subimage is
	1646	* scaled and flipped as needed to preserve those mappings.
	1647	* @param img the specified image to be drawn
	1648	* This method does nothing if <code>img</code> is null.
	1649	* @param dx1 the <i>x</i> coordinate of the first corner of the
	1650	* destination rectangle.
	1651	* @param dy1 the <i>y</i> coordinate of the first corner of the
	1652	* destination rectangle.
	1653	* @param dx2 the <i>x</i> coordinate of the second corner of the
	1654	* destination rectangle.
	1655	* @param dy2 the <i>y</i> coordinate of the second corner of the
	1656	* destination rectangle.
	1657	* @param sx1 the <i>x</i> coordinate of the first corner of the
	1658	* source rectangle.
	1659	* @param sy1 the <i>y</i> coordinate of the first corner of the
	1660	* source rectangle.
	1661	* @param sx2 the <i>x</i> coordinate of the second corner of the
	1662	* source rectangle.
	1663	* @param sy2 the <i>y</i> coordinate of the second corner of the
	1664	* source rectangle.
	1665	* @param bgcolor the background color to paint under the
	1666	* non-opaque portions of the image.
	1667	* @param observer object to be notified as more of the image is
	1668	* scaled and converted.
	1669	* @see java.awt.Image
	1670	* @see java.awt.image.ImageObserver
	1671	* @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
	1672	* @since JDK1.1
	1673	*/
	1674	public boolean drawImage(Image img,
	1675	int dx1, int dy1, int dx2, int dy2,
	1676	int sx1, int sy1, int sx2, int sy2,
	1677	Color bgcolor,
	1678	ImageObserver observer) {
	1679
	1680	if (img == null) {
	1681	return true;
	1682	}
	1683	int imgWidth = img.getWidth(null);
	1684	int imgHeight = img.getHeight(null);
	1685
	1686	if (imgWidth < 0 \|\| imgHeight < 0) {
	1687	return true;
	1688	}
	1689
	1690	int srcWidth = sx2 - sx1;
	1691	int srcHeight = sy2 - sy1;
	1692
	1693	/* Create a transform which describes the changes
	1694	* from the source coordinates to the destination
	1695	* coordinates. The scaling is determined by the
	1696	* ratio of the two rectangles, while the translation
	1697	* comes from the difference of their origins.
	1698	*/
	1699	float scalex = (float) (dx2 - dx1) / srcWidth;
	1700	float scaley = (float) (dy2 - dy1) / srcHeight;
	1701	AffineTransform xForm
	1702	= new AffineTransform(scalex,
	1703	0,
	1704	0,
	1705	scaley,
	1706	dx1 - (sx1 * scalex),
	1707	dy1 - (sy1 * scaley));
	1708
	1709	/* drawImageToPlatform needs the top-left of the source area and
	1710	* a positive width and height. The xform describes how to map
	1711	* src->dest, so that information is not lost.
	1712	*/
	1713	int tmp=0;
	1714	if (sx2 < sx1) {
	1715	tmp = sx1;
	1716	sx1 = sx2;
	1717	sx2 = tmp;
	1718	}
	1719	if (sy2 < sy1) {
	1720	tmp = sy1;
	1721	sy1 = sy2;
	1722	sy2 = tmp;
	1723	}
	1724
	1725	/* if src area is beyond the bounds of the image, we must clip it.
	1726	* The transform is based on the specified area, not the clipped one.
	1727	*/
	1728	if (sx1 < 0) {
	1729	sx1 = 0;
	1730	} else if (sx1 > imgWidth) { // empty srcArea, nothing to draw
	1731	sx1 = imgWidth;
	1732	}
	1733	if (sx2 < 0) { // empty srcArea, nothing to draw
	1734	sx2 = 0;
	1735	} else if (sx2 > imgWidth) {
	1736	sx2 = imgWidth;
	1737	}
	1738	if (sy1 < 0) {
	1739	sy1 = 0;
	1740	} else if (sy1 > imgHeight) { // empty srcArea
	1741	sy1 = imgHeight;
	1742	}
	1743	if (sy2 < 0) { // empty srcArea
	1744	sy2 = 0;
	1745	} else if (sy2 > imgHeight) {
	1746	sy2 = imgHeight;
	1747	}
	1748
	1749	srcWidth = sx2 - sx1;
	1750	srcHeight = sy2 - sy1;
	1751
	1752	if (srcWidth <= 0 \|\| srcHeight <= 0) {
	1753	return true;
	1754	}
	1755
	1756	return drawImageToPlatform(img, xForm, bgcolor,
	1757	sx1, sy1, srcWidth, srcHeight, false);
	1758
	1759
	1760	}
	1761
	1762	/**
	1763	* Draws an image, applying a transform from image space into user space
	1764	* before drawing.
	1765	* The transformation from user space into device space is done with
	1766	* the current transform in the Graphics2D.
	1767	* The given transformation is applied to the image before the
	1768	* transform attribute in the Graphics2D state is applied.
	1769	* The rendering attributes applied include the clip, transform,
	1770	* and composite attributes. Note that the result is
	1771	* undefined, if the given transform is noninvertible.
	1772	* @param img The image to be drawn.
	1773	* This method does nothing if <code>img</code> is null.
	1774	* @param xform The transformation from image space into user space.
	1775	* @param obs The image observer to be notified as more of the image
	1776	* is converted.
	1777	* @see #transform
	1778	* @see #setTransform
	1779	* @see #setComposite
	1780	* @see #clip
	1781	* @see #setClip
	1782	*/
	1783	public boolean drawImage(Image img,
	1784	AffineTransform xform,
	1785	ImageObserver obs) {
	1786
	1787	if (img == null) {
	1788	return true;
	1789	}
	1790
	1791	boolean result;
	1792	int srcWidth = img.getWidth(null);
	1793	int srcHeight = img.getHeight(null);
	1794
	1795	if (srcWidth < 0 \|\| srcHeight < 0) {
	1796	result = false;
	1797	} else {
	1798	result = drawImageToPlatform(img, xform, null,
	1799	0, 0, srcWidth, srcHeight, false);
	1800	}
	1801
	1802	return result;
	1803	}
	1804
	1805	/**
	1806	* Draws a BufferedImage that is filtered with a BufferedImageOp.
	1807	* The rendering attributes applied include the clip, transform
	1808	* and composite attributes. This is equivalent to:
	1809	* <pre>
	1810	* img1 = op.filter(img, null);
	1811	* drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null);
	1812	* </pre>
	1813	* @param op The filter to be applied to the image before drawing.
	1814	* @param img The BufferedImage to be drawn.
	1815	* This method does nothing if <code>img</code> is null.
	1816	* @param x,y The location in user space where the image should be drawn.
	1817	* @see #transform
	1818	* @see #setTransform
	1819	* @see #setComposite
	1820	* @see #clip
	1821	* @see #setClip
	1822	*/
	1823	public void drawImage(BufferedImage img,
	1824	BufferedImageOp op,
	1825	int x,
	1826	int y) {
	1827
	1828	if (img == null) {
	1829	return;
	1830	}
	1831
	1832	int srcWidth = img.getWidth(null);
	1833	int srcHeight = img.getHeight(null);
	1834
	1835	if (op != null) {
	1836	img = op.filter(img, null);
	1837	}
	1838	if (srcWidth <= 0 \|\| srcHeight <= 0) {
	1839	return;
	1840	} else {
	1841	AffineTransform xform = new AffineTransform(1f,0f,0f,1f,x,y);
	1842	drawImageToPlatform(img, xform, null,
	1843	0, 0, srcWidth, srcHeight, false);
	1844	}
	1845
	1846	}
	1847
	1848	/**
	1849	* Draws an image, applying a transform from image space into user space
	1850	* before drawing.
	1851	* The transformation from user space into device space is done with
	1852	* the current transform in the Graphics2D.
	1853	* The given transformation is applied to the image before the
	1854	* transform attribute in the Graphics2D state is applied.
	1855	* The rendering attributes applied include the clip, transform,
	1856	* and composite attributes. Note that the result is
	1857	* undefined, if the given transform is noninvertible.
	1858	* @param img The image to be drawn.
	1859	* This method does nothing if <code>img</code> is null.
	1860	* @param xform The transformation from image space into user space.
	1861	* @see #transform
	1862	* @see #setTransform
	1863	* @see #setComposite
	1864	* @see #clip
	1865	* @see #setClip
	1866	*/
	1867	public void drawRenderedImage(RenderedImage img,
	1868	AffineTransform xform) {
	1869
	1870	if (img == null) {
	1871	return;
	1872	}
	1873
	1874	BufferedImage bufferedImage = null;
	1875	int srcWidth = img.getWidth();
	1876	int srcHeight = img.getHeight();
	1877
	1878	if (srcWidth <= 0 \|\| srcHeight <= 0) {
	1879	return;
	1880	}
	1881
	1882	if (img instanceof BufferedImage) {
	1883	bufferedImage = (BufferedImage) img;
	1884	} else {
	1885	bufferedImage = new BufferedImage(srcWidth, srcHeight,
	1886	BufferedImage.TYPE_INT_ARGB);
	1887	Graphics2D imageGraphics = bufferedImage.createGraphics();
	1888	imageGraphics.drawRenderedImage(img, xform);
	1889	}
	1890
	1891	drawImageToPlatform(bufferedImage, xform, null,
	1892	0, 0, srcWidth, srcHeight, false);
	1893
	1894	}
	1895
	1896	}