plan9-archive/inferno-java

java/pkg/sun/java2d/pipe/AAShapePipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/AAShapePipe.java+215−0

@@ -0,0 +1,215 @@
	1	/*
	2	* Copyright (c) 1997, 2011, 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.java2d.pipe;
	27
	28	import java.awt.BasicStroke;
	29	import java.awt.Rectangle;
	30	import java.awt.Shape;
	31	import java.awt.geom.Rectangle2D;
	32	import java.awt.geom.PathIterator;
	33	import sun.awt.SunHints;
	34	import sun.java2d.SunGraphics2D;
	35
	36	/**
	37	* This class is used to convert raw geometry into 8-bit alpha tiles
	38	* using an AATileGenerator for application by the next stage of
	39	* the pipeline.
	40	* This class sets up the Generator and computes the alpha tiles
	41	* and then passes them on to a CompositePipe object for painting.
	42	*/
	43	public class AAShapePipe
	44	implements ShapeDrawPipe, ParallelogramPipe
	45	{
	46	static RenderingEngine renderengine = RenderingEngine.getInstance();
	47
	48	CompositePipe outpipe;
	49
	50	public AAShapePipe(CompositePipe pipe) {
	51	outpipe = pipe;
	52	}
	53
	54	public void draw(SunGraphics2D sg, Shape s) {
	55	BasicStroke bs;
	56
	57	if (sg.stroke instanceof BasicStroke) {
	58	bs = (BasicStroke) sg.stroke;
	59	} else {
	60	s = sg.stroke.createStrokedShape(s);
	61	bs = null;
	62	}
	63
	64	renderPath(sg, s, bs);
	65	}
	66
	67	public void fill(SunGraphics2D sg, Shape s) {
	68	renderPath(sg, s, null);
	69	}
	70
	71	private static Rectangle2D computeBBox(double ux1, double uy1,
	72	double ux2, double uy2)
	73	{
	74	if ((ux2 -= ux1) < 0) {
	75	ux1 += ux2;
	76	ux2 = -ux2;
	77	}
	78	if ((uy2 -= uy1) < 0) {
	79	uy1 += uy2;
	80	uy2 = -uy2;
	81	}
	82	return new Rectangle2D.Double(ux1, uy1, ux2, uy2);
	83	}
	84
	85	public void fillParallelogram(SunGraphics2D sg,
	86	double ux1, double uy1,
	87	double ux2, double uy2,
	88	double x, double y,
	89	double dx1, double dy1,
	90	double dx2, double dy2)
	91	{
	92	Region clip = sg.getCompClip();
	93	int abox[] = new int[4];
	94	AATileGenerator aatg =
	95	renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, 0, 0,
	96	clip, abox);
	97	if (aatg == null) {
	98	// Nothing to render
	99	return;
	100	}
	101
	102	renderTiles(sg, computeBBox(ux1, uy1, ux2, uy2), aatg, abox);
	103	}
	104
	105	public void drawParallelogram(SunGraphics2D sg,
	106	double ux1, double uy1,
	107	double ux2, double uy2,
	108	double x, double y,
	109	double dx1, double dy1,
	110	double dx2, double dy2,
	111	double lw1, double lw2)
	112	{
	113	Region clip = sg.getCompClip();
	114	int abox[] = new int[4];
	115	AATileGenerator aatg =
	116	renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, lw1, lw2,
	117	clip, abox);
	118	if (aatg == null) {
	119	// Nothing to render
	120	return;
	121	}
	122
	123	// Note that bbox is of the original shape, not the wide path.
	124	// This is appropriate for handing to Paint methods...
	125	renderTiles(sg, computeBBox(ux1, uy1, ux2, uy2), aatg, abox);
	126	}
	127
	128	private static byte[] theTile;
	129
	130	public synchronized static byte[] getAlphaTile(int len) {
	131	byte[] t = theTile;
	132	if (t == null \|\| t.length < len) {
	133	t = new byte[len];
	134	} else {
	135	theTile = null;
	136	}
	137	return t;
	138	}
	139
	140	public synchronized static void dropAlphaTile(byte[] t) {
	141	theTile = t;
	142	}
	143
	144	public void renderPath(SunGraphics2D sg, Shape s, BasicStroke bs) {
	145	boolean adjust = (bs != null &&
	146	sg.strokeHint != SunHints.INTVAL_STROKE_PURE);
	147	boolean thin = (sg.strokeState <= sg.STROKE_THINDASHED);
	148
	149	Region clip = sg.getCompClip();
	150	int abox[] = new int[4];
	151	AATileGenerator aatg =
	152	renderengine.getAATileGenerator(s, sg.transform, clip,
	153	bs, thin, adjust, abox);
	154	if (aatg == null) {
	155	// Nothing to render
	156	return;
	157	}
	158
	159	renderTiles(sg, s, aatg, abox);
	160	}
	161
	162	public void renderTiles(SunGraphics2D sg, Shape s,
	163	AATileGenerator aatg, int abox[])
	164	{
	165	Object context = null;
	166	byte alpha[] = null;
	167	try {
	168	context = outpipe.startSequence(sg, s,
	169	new Rectangle(abox[0], abox[1],
	170	abox[2] - abox[0],
	171	abox[3] - abox[1]),
	172	abox);
	173
	174	int tw = aatg.getTileWidth();
	175	int th = aatg.getTileHeight();
	176	alpha = getAlphaTile(tw * th);
	177
	178	byte[] atile;
	179
	180	for (int y = abox[1]; y < abox[3]; y += th) {
	181	for (int x = abox[0]; x < abox[2]; x += tw) {
	182	int w = Math.min(tw, abox[2] - x);
	183	int h = Math.min(th, abox[3] - y);
	184
	185	int a = aatg.getTypicalAlpha();
	186	if (a == 0x00 \|\|
	187	outpipe.needTile(context, x, y, w, h) == false)
	188	{
	189	aatg.nextTile();
	190	outpipe.skipTile(context, x, y);
	191	continue;
	192	}
	193	if (a == 0xff) {
	194	atile = null;
	195	aatg.nextTile();
	196	} else {
	197	atile = alpha;
	198	aatg.getAlpha(alpha, 0, tw);
	199	}
	200
	201	outpipe.renderPathTile(context, atile, 0, tw,
	202	x, y, w, h);
	203	}
	204	}
	205	} finally {
	206	aatg.dispose();
	207	if (context != null) {
	208	outpipe.endSequence(context);
	209	}
	210	if (alpha != null) {
	211	dropAlphaTile(alpha);
	212	}
	213	}
	214	}
	215	}

java/pkg/sun/java2d/pipe/AATextRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/AATextRenderer.java+45−0

@@ -0,0 +1,45 @@
	1	/*
	2	* Copyright (c) 2000, 2005, 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.java2d.pipe;
	27
	28	import java.awt.font.GlyphVector;
	29	import sun.java2d.SunGraphics2D;
	30	import sun.font.GlyphList;
	31
	32	/**
	33	* A delegate pipe of SG2D for drawing anti-aliased text with
	34	* a solid source colour to an opaque destination.
	35	*/
	36
	37	public class AATextRenderer extends GlyphListLoopPipe
	38	implements LoopBasedPipe
	39	{
	40	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {
	41	sg2d.loops.drawGlyphListAALoop.DrawGlyphListAA(sg2d, sg2d.surfaceData,
	42	gl);
	43	}
	44
	45	}

java/pkg/sun/java2d/pipe/AATileGenerator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/AATileGenerator.java+111−0

@@ -0,0 +1,111 @@
	1	/*
	2	* Copyright (c) 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.java2d.pipe;
	27
	28	/**
	29	* The API for an object that generates alpha coverage tiles for a given
	30	* path.
	31	* The {@link RenderingEngine} will be consulted as a factory to return
	32	* one of these objects for a given Shape and a given set of rendering
	33	* attributes.
	34	* This object will iterate through the bounds of the rendering primitive
	35	* and return tiles of a constant size as specified by the getTileWidth()
	36	* and getTileHeight() parameters.
	37	* The iteration order of the tiles will be as specified by the pseudo-code:
	38	* <pre>
	39	* int bbox[] = {left, top, right, bottom};
	40	* AATileGenerator aatg = renderengine.getAATileGenerator(..., bbox);
	41	* int tw = aatg.getTileWidth();
	42	* int th = aatg.getTileHeight();
	43	* byte tile[] = new byte[tw * th];
	44	* for (y = top; y < bottom; y += th) {
	45	* for (x = left; x < right; x += tw) {
	46	* int a = aatg.getTypicalAlpha();
	47	* int w = Math.min(tw, right-x);
	48	* int h = Math.min(th, bottom-y);
	49	* if (a == 0x00) {
	50	* // can skip this tile...
	51	* aatg.nextTile();
	52	* } else if (a == 0xff) {
	53	* // can treat this tile like a fillRect
	54	* aatg.nextTile();
	55	* doFill(x, y, w, h);
	56	* } else {
	57	* aatg.getAlpha(tile, 0, tw);
	58	* handleAlpha(tile, x, y, w, h);
	59	* }
	60	* }
	61	* }
	62	* aatg.dispose();
	63	* </pre>
	64	* The bounding box for the iteration will be returned by the
	65	* {@code RenderingEngine} via an argument to the getAATileGenerator() method.
	66	*/
	67	public interface AATileGenerator {
	68	/**
	69	* Gets the width of the tiles that the generator batches output into.
	70	* @return the width of the standard alpha tile
	71	*/
	72	public int getTileWidth();
	73
	74	/**
	75	* Gets the height of the tiles that the generator batches output into.
	76	* @return the height of the standard alpha tile
	77	*/
	78	public int getTileHeight();
	79
	80	/**
	81	* Gets the typical alpha value that will characterize the current
	82	* tile.
	83	* The answer may be 0x00 to indicate that the current tile has
	84	* no coverage in any of its pixels, or it may be 0xff to indicate
	85	* that the current tile is completely covered by the path, or any
	86	* other value to indicate non-trivial coverage cases.
	87	* @return 0x00 for no coverage, 0xff for total coverage, or any other
	88	* value for partial coverage of the tile
	89	*/
	90	public int getTypicalAlpha();
	91
	92	/**
	93	* Skips the current tile and moves on to the next tile.
	94	* Either this method, or the getAlpha() method should be called
	95	* once per tile, but not both.
	96	*/
	97	public void nextTile();
	98
	99	/**
	100	* Gets the alpha coverage values for the current tile.
	101	* Either this method, or the nextTile() method should be called
	102	* once per tile, but not both.
	103	*/
	104	public void getAlpha(byte tile[], int offset, int rowstride);
	105
	106	/**
	107	* Disposes this tile generator.
	108	* No further calls will be made on this instance.
	109	*/
	110	public void dispose();
	111	}

java/pkg/sun/java2d/pipe/AlphaColorPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/AlphaColorPipe.java+90−0

@@ -0,0 +1,90 @@
	1	/*
	2	* Copyright (c) 1997, 2010, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.Shape;
	30	import sun.java2d.SunGraphics2D;
	31
	32	/**
	33	* This class implements a CompositePipe that renders path alpha tiles
	34	* into a destination that supports direct alpha compositing of a solid
	35	* color, according to one of the rules in the AlphaComposite class.
	36	*/
	37	public class AlphaColorPipe implements CompositePipe, ParallelogramPipe {
	38	public AlphaColorPipe() {
	39	}
	40
	41	public Object startSequence(SunGraphics2D sg, Shape s, Rectangle dev,
	42	int[] abox) {
	43	return sg;
	44	}
	45
	46	public boolean needTile(Object context, int x, int y, int w, int h) {
	47	return true;
	48	}
	49
	50	public void renderPathTile(Object context,
	51	byte[] atile, int offset, int tilesize,
	52	int x, int y, int w, int h) {
	53	SunGraphics2D sg = (SunGraphics2D) context;
	54
	55	sg.alphafill.MaskFill(sg, sg.getSurfaceData(), sg.composite,
	56	x, y, w, h,
	57	atile, offset, tilesize);
	58	}
	59
	60	public void skipTile(Object context, int x, int y) {
	61	return;
	62	}
	63
	64	public void endSequence(Object context) {
	65	return;
	66	}
	67
	68	public void fillParallelogram(SunGraphics2D sg,
	69	double ux1, double uy1,
	70	double ux2, double uy2,
	71	double x, double y,
	72	double dx1, double dy1,
	73	double dx2, double dy2)
	74	{
	75	sg.alphafill.FillAAPgram(sg, sg.getSurfaceData(), sg.composite,
	76	x, y, dx1, dy1, dx2, dy2);
	77	}
	78
	79	public void drawParallelogram(SunGraphics2D sg,
	80	double ux1, double uy1,
	81	double ux2, double uy2,
	82	double x, double y,
	83	double dx1, double dy1,
	84	double dx2, double dy2,
	85	double lw1, double lw2)
	86	{
	87	sg.alphafill.DrawAAPgram(sg, sg.getSurfaceData(), sg.composite,
	88	x, y, dx1, dy1, dx2, dy2, lw1, lw2);
	89	}
	90	}

java/pkg/sun/java2d/pipe/AlphaPaintPipe$TileContext.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/AlphaPaintPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/AlphaPaintPipe.java+206−0

@@ -0,0 +1,206 @@
	1	/*
	2	* Copyright (c) 1997, 2002, 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.java2d.pipe;
	27
	28	import java.lang.ref.WeakReference;
	29	import java.awt.Rectangle;
	30	import java.awt.Shape;
	31	import java.awt.PaintContext;
	32	import java.awt.Transparency;
	33	import java.awt.image.ColorModel;
	34	import java.awt.image.Raster;
	35	import java.awt.image.WritableRaster;
	36	import java.awt.image.BufferedImage;
	37	import sun.awt.image.BufImgSurfaceData;
	38	import sun.java2d.SunGraphics2D;
	39	import sun.java2d.SurfaceData;
	40	import sun.java2d.loops.Blit;
	41	import sun.java2d.loops.MaskBlit;
	42	import sun.java2d.loops.CompositeType;
	43	import sun.java2d.loops.GraphicsPrimitiveMgr;
	44
	45	/**
	46	* This class implements a CompositePipe that renders path alpha tiles
	47	* into a destination according to the Composite attribute of a
	48	* SunGraphics2D.
	49	*/
	50	public class AlphaPaintPipe implements CompositePipe {
	51	static WeakReference cachedLastRaster;
	52	static WeakReference cachedLastColorModel;
	53	static WeakReference cachedLastData;
	54
	55	static class TileContext {
	56	SunGraphics2D sunG2D;
	57	PaintContext paintCtxt;
	58	ColorModel paintModel;
	59	WeakReference lastRaster;
	60	WeakReference lastData;
	61	MaskBlit lastMask;
	62	Blit lastBlit;
	63	SurfaceData dstData;
	64
	65	public TileContext(SunGraphics2D sg, PaintContext pc) {
	66	sunG2D = sg;
	67	paintCtxt = pc;
	68	paintModel = pc.getColorModel();
	69	dstData = sg.getSurfaceData();
	70	synchronized (AlphaPaintPipe.class) {
	71	if (cachedLastColorModel != null &&
	72	cachedLastColorModel.get() == paintModel)
	73	{
	74	this.lastRaster = cachedLastRaster;
	75	this.lastData = cachedLastData;
	76	}
	77	}
	78	}
	79	}
	80
	81	public Object startSequence(SunGraphics2D sg, Shape s, Rectangle devR,
	82	int[] abox) {
	83	PaintContext paintContext =
	84	sg.paint.createContext(sg.getDeviceColorModel(),
	85	devR,
	86	s.getBounds2D(),
	87	sg.cloneTransform(),
	88	sg.getRenderingHints());
	89	return new TileContext(sg, paintContext);
	90	}
	91
	92	public boolean needTile(Object context, int x, int y, int w, int h) {
	93	return true;
	94	}
	95
	96	private static final int TILE_SIZE = 32;
	97
	98	public void renderPathTile(Object ctx,
	99	byte[] atile, int offset, int tilesize,
	100	int x, int y, int w, int h) {
	101	TileContext context = (TileContext) ctx;
	102	PaintContext paintCtxt = context.paintCtxt;
	103	SunGraphics2D sg = context.sunG2D;
	104	SurfaceData dstData = context.dstData;
	105	SurfaceData srcData = null;
	106	Raster lastRas = null;
	107	if (context.lastData != null && context.lastRaster != null) {
	108	srcData = (SurfaceData) context.lastData.get();
	109	lastRas = (Raster) context.lastRaster.get();
	110	if (srcData == null \|\| lastRas == null) {
	111	srcData = null;
	112	lastRas = null;
	113	}
	114	}
	115	ColorModel paintModel = context.paintModel;
	116
	117	for (int rely = 0; rely < h; rely += TILE_SIZE) {
	118	int ty = y + rely;
	119	int th = Math.min(h-rely, TILE_SIZE);
	120	for (int relx = 0; relx < w; relx += TILE_SIZE) {
	121	int tx = x + relx;
	122	int tw = Math.min(w-relx, TILE_SIZE);
	123
	124	Raster srcRaster = paintCtxt.getRaster(tx, ty, tw, th);
	125	if ((srcRaster.getMinX() != 0) \|\| (srcRaster.getMinY() != 0)) {
	126	srcRaster = srcRaster.createTranslatedChild(0, 0);
	127	}
	128	if (lastRas != srcRaster) {
	129	lastRas = srcRaster;
	130	context.lastRaster = new WeakReference(lastRas);
	131	// REMIND: This will fail for a non-Writable raster!
	132	BufferedImage bImg =
	133	new BufferedImage(paintModel,
	134	(WritableRaster) srcRaster,
	135	paintModel.isAlphaPremultiplied(),
	136	null);
	137	srcData = BufImgSurfaceData.createData(bImg);
	138	context.lastData = new WeakReference(srcData);
	139	context.lastMask = null;
	140	context.lastBlit = null;
	141	}
	142
	143	if (atile == null) {
	144	if (context.lastBlit == null) {
	145	CompositeType comptype = sg.imageComp;
	146	if (CompositeType.SrcOverNoEa.equals(comptype) &&
	147	paintModel.getTransparency() == Transparency.OPAQUE)
	148	{
	149	comptype = CompositeType.SrcNoEa;
	150	}
	151	context.lastBlit =
	152	Blit.getFromCache(srcData.getSurfaceType(),
	153	comptype,
	154	dstData.getSurfaceType());
	155	}
	156	context.lastBlit.Blit(srcData, dstData,
	157	sg.composite, null,
	158	0, 0, tx, ty, tw, th);
	159	} else {
	160	if (context.lastMask == null) {
	161	CompositeType comptype = sg.imageComp;
	162	if (CompositeType.SrcOverNoEa.equals(comptype) &&
	163	paintModel.getTransparency() == Transparency.OPAQUE)
	164	{
	165	comptype = CompositeType.SrcNoEa;
	166	}
	167	context.lastMask =
	168	MaskBlit.getFromCache(srcData.getSurfaceType(),
	169	comptype,
	170	dstData.getSurfaceType());
	171	}
	172
	173	int toff = offset + rely * tilesize + relx;
	174	context.lastMask.MaskBlit(srcData, dstData,
	175	sg.composite, null,
	176	0, 0, tx, ty, tw, th,
	177	atile, toff, tilesize);
	178	}
	179	}
	180	}
	181	}
	182
	183	public void skipTile(Object context, int x, int y) {
	184	return;
	185	}
	186
	187	public void endSequence(Object ctx) {
	188	TileContext context = (TileContext) ctx;
	189	if (context.paintCtxt != null) {
	190	context.paintCtxt.dispose();
	191	}
	192	synchronized (AlphaPaintPipe.class) {
	193	if (context.lastData != null) {
	194	cachedLastRaster = context.lastRaster;
	195	if (cachedLastColorModel == null \|\|
	196	cachedLastColorModel.get() != context.paintModel)
	197	{
	198	// Avoid creating new WeakReference if possible
	199	cachedLastColorModel =
	200	new WeakReference(context.paintModel);
	201	}
	202	cachedLastData = context.lastData;
	203	}
	204	}
	205	}
	206	}

java/pkg/sun/java2d/pipe/BufferedBufImgOps.java+393−0

@@ -0,0 +1,393 @@
	1	/*
	2	* Copyright (c) 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.java2d.pipe;
	27
	28	import java.awt.color.ColorSpace;
	29	import java.awt.image.AffineTransformOp;
	30	import java.awt.image.BufferedImage;
	31	import java.awt.image.BufferedImageOp;
	32	import java.awt.image.BufferedImageOp;
	33	import java.awt.image.ByteLookupTable;
	34	import java.awt.image.ColorModel;
	35	import java.awt.image.ConvolveOp;
	36	import java.awt.image.IndexColorModel;
	37	import java.awt.image.Kernel;
	38	import java.awt.image.LookupOp;
	39	import java.awt.image.LookupTable;
	40	import java.awt.image.RescaleOp;
	41	import java.awt.image.ShortLookupTable;
	42	import sun.java2d.SurfaceData;
	43	import sun.java2d.loops.CompositeType;
	44	import static sun.java2d.pipe.BufferedOpCodes.*;
	45
	46	public class BufferedBufImgOps {
	47
	48	public static void enableBufImgOp(RenderQueue rq, SurfaceData srcData,
	49	BufferedImage srcImg,
	50	BufferedImageOp biop)
	51	{
	52	if (biop instanceof ConvolveOp) {
	53	enableConvolveOp(rq, srcData, (ConvolveOp)biop);
	54	} else if (biop instanceof RescaleOp) {
	55	enableRescaleOp(rq, srcData, srcImg, (RescaleOp)biop);
	56	} else if (biop instanceof LookupOp) {
	57	enableLookupOp(rq, srcData, srcImg, (LookupOp)biop);
	58	} else {
	59	throw new InternalError("Unknown BufferedImageOp");
	60	}
	61	}
	62
	63	public static void disableBufImgOp(RenderQueue rq, BufferedImageOp biop) {
	64	if (biop instanceof ConvolveOp) {
	65	disableConvolveOp(rq);
	66	} else if (biop instanceof RescaleOp) {
	67	disableRescaleOp(rq);
	68	} else if (biop instanceof LookupOp) {
	69	disableLookupOp(rq);
	70	} else {
	71	throw new InternalError("Unknown BufferedImageOp");
	72	}
	73	}
	74
	75	/************************** ConvolveOp support **************************/
	76
	77	public static boolean isConvolveOpValid(ConvolveOp cop) {
	78	Kernel kernel = cop.getKernel();
	79	int kw = kernel.getWidth();
	80	int kh = kernel.getHeight();
	81	// REMIND: we currently can only handle 3x3 and 5x5 kernels,
	82	// but hopefully this is just a temporary restriction;
	83	// see native shader comments for more details
	84	if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
	85	return false;
	86	}
	87	return true;
	88	}
	89
	90	private static void enableConvolveOp(RenderQueue rq,
	91	SurfaceData srcData,
	92	ConvolveOp cop)
	93	{
	94	// assert rq.lock.isHeldByCurrentThread();
	95	boolean edgeZero =
	96	cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
	97	Kernel kernel = cop.getKernel();
	98	int kernelWidth = kernel.getWidth();
	99	int kernelHeight = kernel.getHeight();
	100	int kernelSize = kernelWidth * kernelHeight;
	101	int sizeofFloat = 4;
	102	int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
	103
	104	RenderBuffer buf = rq.getBuffer();
	105	rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
	106	buf.putInt(ENABLE_CONVOLVE_OP);
	107	buf.putLong(srcData.getNativeOps());
	108	buf.putInt(edgeZero ? 1 : 0);
	109	buf.putInt(kernelWidth);
	110	buf.putInt(kernelHeight);
	111	buf.put(kernel.getKernelData(null));
	112	}
	113
	114	private static void disableConvolveOp(RenderQueue rq) {
	115	// assert rq.lock.isHeldByCurrentThread();
	116	RenderBuffer buf = rq.getBuffer();
	117	rq.ensureCapacity(4);
	118	buf.putInt(DISABLE_CONVOLVE_OP);
	119	}
	120
	121	/************************** RescaleOp support ***************************/
	122
	123	public static boolean isRescaleOpValid(RescaleOp rop,
	124	BufferedImage srcImg)
	125	{
	126	int numFactors = rop.getNumFactors();
	127	ColorModel srcCM = srcImg.getColorModel();
	128
	129	if (srcCM instanceof IndexColorModel) {
	130	throw new
	131	IllegalArgumentException("Rescaling cannot be "+
	132	"performed on an indexed image");
	133	}
	134	if (numFactors != 1 &&
	135	numFactors != srcCM.getNumColorComponents() &&
	136	numFactors != srcCM.getNumComponents())
	137	{
	138	throw new IllegalArgumentException("Number of scaling constants "+
	139	"does not equal the number of"+
	140	" of color or color/alpha "+
	141	" components");
	142	}
	143
	144	int csType = srcCM.getColorSpace().getType();
	145	if (csType != ColorSpace.TYPE_RGB &&
	146	csType != ColorSpace.TYPE_GRAY)
	147	{
	148	// Not prepared to deal with other color spaces
	149	return false;
	150	}
	151
	152	if (numFactors == 2 \|\| numFactors > 4) {
	153	// Not really prepared to handle this at the native level, so...
	154	return false;
	155	}
	156
	157	return true;
	158	}
	159
	160	private static void enableRescaleOp(RenderQueue rq,
	161	SurfaceData srcData,
	162	BufferedImage srcImg,
	163	RescaleOp rop)
	164	{
	165	// assert rq.lock.isHeldByCurrentThread();
	166	ColorModel srcCM = srcImg.getColorModel();
	167	boolean nonPremult =
	168	srcCM.hasAlpha() &&
	169	srcCM.isAlphaPremultiplied();
	170
	171	/*
	172	* Note: The user-provided scale factors and offsets are arranged
	173	* in R/G/B/A order, regardless of the raw data order of the
	174	* underlying Raster/DataBuffer. The source image data is ultimately
	175	* converted into RGBA data when uploaded to an OpenGL texture
	176	* (even for TYPE_GRAY), so the scale factors and offsets are already
	177	* in the order expected by the native OpenGL code.
	178	*
	179	* However, the offsets provided by the user are in a range dictated
	180	* by the size of each color/alpha band in the source image. For
	181	* example, for 8/8/8 data each offset is in the range [0,255],
	182	* for 5/5/5 data each offset is in the range [0,31], and so on.
	183	* The OpenGL shader only thinks in terms of [0,1], so below we need
	184	* to normalize the user-provided offset values into the range [0,1].
	185	*/
	186	int numFactors = rop.getNumFactors();
	187	float[] origScaleFactors = rop.getScaleFactors(null);
	188	float[] origOffsets = rop.getOffsets(null);
	189
	190	// To make things easier, we will always pass all four bands
	191	// down to native code...
	192	float[] normScaleFactors;
	193	float[] normOffsets;
	194
	195	if (numFactors == 1) {
	196	normScaleFactors = new float[4];
	197	normOffsets = new float[4];
	198	for (int i = 0; i < 3; i++) {
	199	normScaleFactors[i] = origScaleFactors[0];
	200	normOffsets[i] = origOffsets[0];
	201	}
	202	// Leave alpha untouched...
	203	normScaleFactors[3] = 1.0f;
	204	normOffsets[3] = 0.0f;
	205	} else if (numFactors == 3) {
	206	normScaleFactors = new float[4];
	207	normOffsets = new float[4];
	208	for (int i = 0; i < 3; i++) {
	209	normScaleFactors[i] = origScaleFactors[i];
	210	normOffsets[i] = origOffsets[i];
	211	}
	212	// Leave alpha untouched...
	213	normScaleFactors[3] = 1.0f;
	214	normOffsets[3] = 0.0f;
	215	} else { // (numFactors == 4)
	216	normScaleFactors = origScaleFactors;
	217	normOffsets = origOffsets;
	218	}
	219
	220	// The user-provided offsets are specified in the range
	221	// of each source color band, but the OpenGL shader only wants
	222	// to deal with data in the range [0,1], so we need to normalize
	223	// each offset value to the range [0,1] here.
	224	if (srcCM.getNumComponents() == 1) {
	225	// Gray data
	226	int nBits = srcCM.getComponentSize(0);
	227	int maxValue = (1 << nBits) - 1;
	228	for (int i = 0; i < 3; i++) {
	229	normOffsets[i] /= maxValue;
	230	}
	231	} else {
	232	// RGB(A) data
	233	for (int i = 0; i < srcCM.getNumComponents(); i++) {
	234	int nBits = srcCM.getComponentSize(i);
	235	int maxValue = (1 << nBits) - 1;
	236	normOffsets[i] /= maxValue;
	237	}
	238	}
	239
	240	int sizeofFloat = 4;
	241	int totalBytesRequired = 4 + 8 + 4 + (4 * sizeofFloat * 2);
	242
	243	RenderBuffer buf = rq.getBuffer();
	244	rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
	245	buf.putInt(ENABLE_RESCALE_OP);
	246	buf.putLong(srcData.getNativeOps());
	247	buf.putInt(nonPremult ? 1 : 0);
	248	buf.put(normScaleFactors);
	249	buf.put(normOffsets);
	250	}
	251
	252	private static void disableRescaleOp(RenderQueue rq) {
	253	// assert rq.lock.isHeldByCurrentThread();
	254	RenderBuffer buf = rq.getBuffer();
	255	rq.ensureCapacity(4);
	256	buf.putInt(DISABLE_RESCALE_OP);
	257	}
	258
	259	/************************** LookupOp support ****************************/
	260
	261	public static boolean isLookupOpValid(LookupOp lop,
	262	BufferedImage srcImg)
	263	{
	264	LookupTable table = lop.getTable();
	265	int numComps = table.getNumComponents();
	266	ColorModel srcCM = srcImg.getColorModel();
	267
	268	if (srcCM instanceof IndexColorModel) {
	269	throw new
	270	IllegalArgumentException("LookupOp cannot be "+
	271	"performed on an indexed image");
	272	}
	273	if (numComps != 1 &&
	274	numComps != srcCM.getNumComponents() &&
	275	numComps != srcCM.getNumColorComponents())
	276	{
	277	throw new IllegalArgumentException("Number of arrays in the "+
	278	" lookup table ("+
	279	numComps+
	280	") is not compatible with"+
	281	" the src image: "+srcImg);
	282	}
	283
	284	int csType = srcCM.getColorSpace().getType();
	285	if (csType != ColorSpace.TYPE_RGB &&
	286	csType != ColorSpace.TYPE_GRAY)
	287	{
	288	// Not prepared to deal with other color spaces
	289	return false;
	290	}
	291
	292	if (numComps == 2 \|\| numComps > 4) {
	293	// Not really prepared to handle this at the native level, so...
	294	return false;
	295	}
	296
	297	// The LookupTable spec says that "all arrays must be the
	298	// same size" but unfortunately the constructors do not
	299	// enforce that. Also, our native code only works with
	300	// arrays no larger than 256 elements, so check both of
	301	// these restrictions here.
	302	if (table instanceof ByteLookupTable) {
	303	byte[][] data = ((ByteLookupTable)table).getTable();
	304	for (int i = 1; i < data.length; i++) {
	305	if (data[i].length > 256 \|\|
	306	data[i].length != data[i-1].length)
	307	{
	308	return false;
	309	}
	310	}
	311	} else if (table instanceof ShortLookupTable) {
	312	short[][] data = ((ShortLookupTable)table).getTable();
	313	for (int i = 1; i < data.length; i++) {
	314	if (data[i].length > 256 \|\|
	315	data[i].length != data[i-1].length)
	316	{
	317	return false;
	318	}
	319	}
	320	} else {
	321	return false;
	322	}
	323
	324	return true;
	325	}
	326
	327	private static void enableLookupOp(RenderQueue rq,
	328	SurfaceData srcData,
	329	BufferedImage srcImg,
	330	LookupOp lop)
	331	{
	332	// assert rq.lock.isHeldByCurrentThread();
	333	boolean nonPremult =
	334	srcImg.getColorModel().hasAlpha() &&
	335	srcImg.isAlphaPremultiplied();
	336
	337	LookupTable table = lop.getTable();
	338	int numBands = table.getNumComponents();
	339	int offset = table.getOffset();
	340	int bandLength;
	341	int bytesPerElem;
	342	boolean shortData;
	343
	344	if (table instanceof ShortLookupTable) {
	345	short[][] data = ((ShortLookupTable)table).getTable();
	346	bandLength = data[0].length;
	347	bytesPerElem = 2;
	348	shortData = true;
	349	} else { // (table instanceof ByteLookupTable)
	350	byte[][] data = ((ByteLookupTable)table).getTable();
	351	bandLength = data[0].length;
	352	bytesPerElem = 1;
	353	shortData = false;
	354	}
	355
	356	// Adjust the LUT length so that it ends on a 4-byte boundary
	357	int totalLutBytes = numBands * bandLength * bytesPerElem;
	358	int paddedLutBytes = (totalLutBytes + 3) & (~3);
	359	int padding = paddedLutBytes - totalLutBytes;
	360	int totalBytesRequired = 4 + 8 + 20 + paddedLutBytes;
	361
	362	RenderBuffer buf = rq.getBuffer();
	363	rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
	364	buf.putInt(ENABLE_LOOKUP_OP);
	365	buf.putLong(srcData.getNativeOps());
	366	buf.putInt(nonPremult ? 1 : 0);
	367	buf.putInt(shortData ? 1 : 0);
	368	buf.putInt(numBands);
	369	buf.putInt(bandLength);
	370	buf.putInt(offset);
	371	if (shortData) {
	372	short[][] data = ((ShortLookupTable)table).getTable();
	373	for (int i = 0; i < numBands; i++) {
	374	buf.put(data[i]);
	375	}
	376	} else {
	377	byte[][] data = ((ByteLookupTable)table).getTable();
	378	for (int i = 0; i < numBands; i++) {
	379	buf.put(data[i]);
	380	}
	381	}
	382	if (padding != 0) {
	383	buf.position(buf.position() + padding);
	384	}
	385	}
	386
	387	private static void disableLookupOp(RenderQueue rq) {
	388	// assert rq.lock.isHeldByCurrentThread();
	389	RenderBuffer buf = rq.getBuffer();
	390	rq.ensureCapacity(4);
	391	buf.putInt(DISABLE_LOOKUP_OP);
	392	}
	393	}

java/pkg/sun/java2d/pipe/BufferedContext.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedContext.java+470−0

@@ -0,0 +1,470 @@
	1	/*
	2	* Copyright (c) 2005, 2008, 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.java2d.pipe;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.Color;
	30	import java.awt.Composite;
	31	import java.awt.Paint;
	32	import java.awt.geom.AffineTransform;
	33	import sun.java2d.pipe.hw.AccelSurface;
	34	import sun.java2d.InvalidPipeException;
	35	import sun.java2d.SunGraphics2D;
	36	import sun.java2d.loops.XORComposite;
	37	import static sun.java2d.pipe.BufferedOpCodes.*;
	38	import static sun.java2d.pipe.BufferedRenderPipe.BYTES_PER_SPAN;
	39
	40	/**
	41	* Base context class for managing state in a single-threaded rendering
	42	* environment. Each state-setting operation (e.g. SET_COLOR) is added to
	43	* the provided RenderQueue, which will be processed at a later time by a
	44	* single thread. Note that the RenderQueue lock must be acquired before
	45	* calling the validate() method (or any other method in this class). See
	46	* the RenderQueue class comments for a sample usage scenario.
	47	*
	48	* @see RenderQueue
	49	*/
	50	public abstract class BufferedContext {
	51
	52	/*
	53	* The following flags help the internals of validate() determine
	54	* the appropriate (meaning correct, or optimal) code path when
	55	* setting up the current context. The flags can be bitwise OR'd
	56	* together as needed.
	57	*/
	58
	59	/**
	60	* Indicates that no flags are needed; take all default code paths.
	61	*/
	62	public static final int NO_CONTEXT_FLAGS = (0 << 0);
	63	/**
	64	* Indicates that the source surface (or color value, if it is a simple
	65	* rendering operation) is opaque (has an alpha value of 1.0). If this
	66	* flag is present, it allows us to disable blending in certain
	67	* situations in order to improve performance.
	68	*/
	69	public static final int SRC_IS_OPAQUE = (1 << 0);
	70	/**
	71	* Indicates that the operation uses an alpha mask, which may determine
	72	* the code path that is used when setting up the current paint state.
	73	*/
	74	public static final int USE_MASK = (1 << 1);
	75
	76	protected RenderQueue rq;
	77	protected RenderBuffer buf;
	78
	79	/**
	80	* This is a reference to the most recently validated BufferedContext. If
	81	* this value is null, it means that there is no current context. It is
	82	* provided here so that validate() only needs to do a quick reference
	83	* check to see if the BufferedContext passed to that method is the same
	84	* as the one we've cached here.
	85	*/
	86	protected static BufferedContext currentContext;
	87
	88	private AccelSurface validatedSrcData;
	89	private AccelSurface validatedDstData;
	90	private Region validatedClip;
	91	private Composite validatedComp;
	92	private Paint validatedPaint;
	93	// renamed from isValidatedPaintAColor as part of a work around for 6764257
	94	private boolean isValidatedPaintJustAColor;
	95	private int validatedRGB;
	96	private int validatedFlags;
	97	private boolean xformInUse;
	98	private int transX;
	99	private int transY;
	100
	101	protected BufferedContext(RenderQueue rq) {
	102	this.rq = rq;
	103	this.buf = rq.getBuffer();
	104	}
	105
	106	/**
	107	* Fetches the BufferedContextContext associated with the dst. surface
	108	* and validates the context using the given parameters. Most rendering
	109	* operations will call this method first in order to set the necessary
	110	* state before issuing rendering commands.
	111	*
	112	* Note: must be called while the RenderQueue lock is held.
	113	*
	114	* @throws InvalidPipeException if either src or dest surface is not valid
	115	* or lost
	116	* @see RenderQueue#lock
	117	* @see RenderQueue#unlock
	118	*/
	119	public static void validateContext(AccelSurface srcData,
	120	AccelSurface dstData,
	121	Region clip, Composite comp,
	122	AffineTransform xform,
	123	Paint paint, SunGraphics2D sg2d,
	124	int flags)
	125	{
	126	// assert rq.lock.isHeldByCurrentThread();
	127	BufferedContext d3dc = dstData.getContext();
	128	d3dc.validate(srcData, dstData,
	129	clip, comp, xform, paint, sg2d, flags);
	130	}
	131
	132	/**
	133	* Fetches the BufferedContextassociated with the surface
	134	* and disables all context state settings.
	135	*
	136	* Note: must be called while the RenderQueue lock is held.
	137	*
	138	* @throws InvalidPipeException if the surface is not valid
	139	* or lost
	140	* @see RenderQueue#lock
	141	* @see RenderQueue#unlock
	142	*/
	143	public static void validateContext(AccelSurface surface) {
	144	// assert rt.lock.isHeldByCurrentThread();
	145	validateContext(surface, surface,
	146	null, null, null, null, null, NO_CONTEXT_FLAGS);
	147	}
	148
	149	/**
	150	* Validates the given parameters against the current state for this
	151	* context. If this context is not current, it will be made current
	152	* for the given source and destination surfaces, and the viewport will
	153	* be updated. Then each part of the context state (clip, composite,
	154	* etc.) is checked against the previous value. If the value has changed
	155	* since the last call to validate(), it will be updated accordingly.
	156	*
	157	* Note that the SunGraphics2D parameter is only used for the purposes
	158	* of validating a (non-null) Paint parameter. In all other cases it
	159	* is safe to pass a null SunGraphics2D and it will be ignored.
	160	*
	161	* Note: must be called while the RenderQueue lock is held.
	162	*
	163	* @throws InvalidPipeException if either src or dest surface is not valid
	164	* or lost
	165	*/
	166	public void validate(AccelSurface srcData, AccelSurface dstData,
	167	Region clip, Composite comp,
	168	AffineTransform xform,
	169	Paint paint, SunGraphics2D sg2d, int flags)
	170	{
	171	// assert rq.lock.isHeldByCurrentThread();
	172
	173	boolean updateClip = false;
	174	boolean updatePaint = false;
	175
	176	if (!dstData.isValid() \|\|
	177	dstData.isSurfaceLost() \|\| srcData.isSurfaceLost())
	178	{
	179	invalidateContext();
	180	throw new InvalidPipeException("bounds changed or surface lost");
	181	}
	182
	183	if (paint instanceof Color) {
	184	// REMIND: not 30-bit friendly
	185	int newRGB = ((Color)paint).getRGB();
	186	if (isValidatedPaintJustAColor) {
	187	if (newRGB != validatedRGB) {
	188	validatedRGB = newRGB;
	189	updatePaint = true;
	190	}
	191	} else {
	192	validatedRGB = newRGB;
	193	updatePaint = true;
	194	isValidatedPaintJustAColor = true;
	195	}
	196	} else if (validatedPaint != paint) {
	197	updatePaint = true;
	198	// this should be set when we are switching from paint to color
	199	// in which case this condition will be true
	200	isValidatedPaintJustAColor = false;
	201	}
	202
	203	if ((currentContext != this) \|\|
	204	(srcData != validatedSrcData) \|\|
	205	(dstData != validatedDstData))
	206	{
	207	if (dstData != validatedDstData) {
	208	// the clip is dependent on the destination surface, so we
	209	// need to update it if we have a new destination surface
	210	updateClip = true;
	211	}
	212
	213	if (paint == null) {
	214	// make sure we update the color state (otherwise, it might
	215	// not be updated if this is the first time the context
	216	// is being validated)
	217	updatePaint = true;
	218	}
	219
	220	// update the current source and destination surfaces
	221	setSurfaces(srcData, dstData);
	222
	223	currentContext = this;
	224	validatedSrcData = srcData;
	225	validatedDstData = dstData;
	226	}
	227
	228	// validate clip
	229	if ((clip != validatedClip) \|\| updateClip) {
	230	if (clip != null) {
	231	if (updateClip \|\|
	232	validatedClip == null \|\|
	233	!(validatedClip.isRectangular() && clip.isRectangular()) \|\|
	234	((clip.getLoX() != validatedClip.getLoX() \|\|
	235	clip.getLoY() != validatedClip.getLoY() \|\|
	236	clip.getHiX() != validatedClip.getHiX() \|\|
	237	clip.getHiY() != validatedClip.getHiY())))
	238	{
	239	setClip(clip);
	240	}
	241	} else {
	242	resetClip();
	243	}
	244	validatedClip = clip;
	245	}
	246
	247	// validate composite (note that a change in the context flags
	248	// may require us to update the composite state, even if the
	249	// composite has not changed)
	250	if ((comp != validatedComp) \|\| (flags != validatedFlags)) {
	251	if (comp != null) {
	252	setComposite(comp, flags);
	253	} else {
	254	resetComposite();
	255	}
	256	// the paint state is dependent on the composite state, so make
	257	// sure we update the color below
	258	updatePaint = true;
	259	validatedComp = comp;
	260	validatedFlags = flags;
	261	}
	262
	263	// validate transform
	264	boolean txChanged = false;
	265	if (xform == null) {
	266	if (xformInUse) {
	267	resetTransform();
	268	xformInUse = false;
	269	txChanged = true;
	270	} else if (sg2d != null) {
	271	if (transX != sg2d.transX \|\| transY != sg2d.transY) {
	272	txChanged = true;
	273	}
	274	}
	275	if (sg2d != null) {
	276	transX = sg2d.transX;
	277	transY = sg2d.transY;
	278	}
	279	} else {
	280	setTransform(xform);
	281	xformInUse = true;
	282	txChanged = true;
	283	}
	284	// non-Color paints may require paint revalidation
	285	if (!isValidatedPaintJustAColor && txChanged) {
	286	updatePaint = true;
	287	}
	288
	289	// validate paint
	290	if (updatePaint) {
	291	if (paint != null) {
	292	BufferedPaints.setPaint(rq, sg2d, paint, flags);
	293	} else {
	294	BufferedPaints.resetPaint(rq);
	295	}
	296	validatedPaint = paint;
	297	}
	298
	299	// mark dstData dirty
	300	// REMIND: is this really needed now? we do it in SunGraphics2D..
	301	dstData.markDirty();
	302	}
	303
	304	/**
	305	* Invalidates the surfaces associated with this context. This is
	306	* useful when the context is no longer needed, and we want to break
	307	* the chain caused by these surface references.
	308	*
	309	* Note: must be called while the RenderQueue lock is held.
	310	*
	311	* @see RenderQueue#lock
	312	* @see RenderQueue#unlock
	313	*/
	314	public void invalidateSurfaces() {
	315	validatedSrcData = null;
	316	validatedDstData = null;
	317	}
	318
	319	private void setSurfaces(AccelSurface srcData,
	320	AccelSurface dstData)
	321	{
	322	// assert rq.lock.isHeldByCurrentThread();
	323	rq.ensureCapacityAndAlignment(20, 4);
	324	buf.putInt(SET_SURFACES);
	325	buf.putLong(srcData.getNativeOps());
	326	buf.putLong(dstData.getNativeOps());
	327	}
	328
	329	private void resetClip() {
	330	// assert rq.lock.isHeldByCurrentThread();
	331	rq.ensureCapacity(4);
	332	buf.putInt(RESET_CLIP);
	333	}
	334
	335	private void setClip(Region clip) {
	336	// assert rq.lock.isHeldByCurrentThread();
	337	if (clip.isRectangular()) {
	338	rq.ensureCapacity(20);
	339	buf.putInt(SET_RECT_CLIP);
	340	buf.putInt(clip.getLoX()).putInt(clip.getLoY());
	341	buf.putInt(clip.getHiX()).putInt(clip.getHiY());
	342	} else {
	343	rq.ensureCapacity(28); // so that we have room for at least a span
	344	buf.putInt(BEGIN_SHAPE_CLIP);
	345	buf.putInt(SET_SHAPE_CLIP_SPANS);
	346	// include a placeholder for the span count
	347	int countIndex = buf.position();
	348	buf.putInt(0);
	349	int spanCount = 0;
	350	int remainingSpans = buf.remaining() / BYTES_PER_SPAN;
	351	int span[] = new int[4];
	352	SpanIterator si = clip.getSpanIterator();
	353	while (si.nextSpan(span)) {
	354	if (remainingSpans == 0) {
	355	buf.putInt(countIndex, spanCount);
	356	rq.flushNow();
	357	buf.putInt(SET_SHAPE_CLIP_SPANS);
	358	countIndex = buf.position();
	359	buf.putInt(0);
	360	spanCount = 0;
	361	remainingSpans = buf.remaining() / BYTES_PER_SPAN;
	362	}
	363	buf.putInt(span[0]); // x1
	364	buf.putInt(span[1]); // y1
	365	buf.putInt(span[2]); // x2
	366	buf.putInt(span[3]); // y2
	367	spanCount++;
	368	remainingSpans--;
	369	}
	370	buf.putInt(countIndex, spanCount);
	371	rq.ensureCapacity(4);
	372	buf.putInt(END_SHAPE_CLIP);
	373	}
	374	}
	375
	376	private void resetComposite() {
	377	// assert rq.lock.isHeldByCurrentThread();
	378	rq.ensureCapacity(4);
	379	buf.putInt(RESET_COMPOSITE);
	380	}
	381
	382	private void setComposite(Composite comp, int flags) {
	383	// assert rq.lock.isHeldByCurrentThread();
	384	if (comp instanceof AlphaComposite) {
	385	AlphaComposite ac = (AlphaComposite)comp;
	386	rq.ensureCapacity(16);
	387	buf.putInt(SET_ALPHA_COMPOSITE);
	388	buf.putInt(ac.getRule());
	389	buf.putFloat(ac.getAlpha());
	390	buf.putInt(flags);
	391	} else if (comp instanceof XORComposite) {
	392	int xorPixel = ((XORComposite)comp).getXorPixel();
	393	rq.ensureCapacity(8);
	394	buf.putInt(SET_XOR_COMPOSITE);
	395	buf.putInt(xorPixel);
	396	} else {
	397	throw new InternalError("not yet implemented");
	398	}
	399	}
	400
	401	private void resetTransform() {
	402	// assert rq.lock.isHeldByCurrentThread();
	403	rq.ensureCapacity(4);
	404	buf.putInt(RESET_TRANSFORM);
	405	}
	406
	407	private void setTransform(AffineTransform xform) {
	408	// assert rq.lock.isHeldByCurrentThread();
	409	rq.ensureCapacityAndAlignment(52, 4);
	410	buf.putInt(SET_TRANSFORM);
	411	buf.putDouble(xform.getScaleX());
	412	buf.putDouble(xform.getShearY());
	413	buf.putDouble(xform.getShearX());
	414	buf.putDouble(xform.getScaleY());
	415	buf.putDouble(xform.getTranslateX());
	416	buf.putDouble(xform.getTranslateY());
	417	}
	418
	419	/**
	420	* Resets this context's surfaces and all attributes.
	421	*
	422	* Note: must be called while the RenderQueue lock is held.
	423	*
	424	* @see RenderQueue#lock
	425	* @see RenderQueue#unlock
	426	*/
	427	public void invalidateContext() {
	428	resetTransform();
	429	resetComposite();
	430	resetClip();
	431	BufferedPaints.resetPaint(rq);
	432	invalidateSurfaces();
	433	validatedComp = null;
	434	validatedClip = null;
	435	validatedPaint = null;
	436	isValidatedPaintJustAColor = false;
	437	xformInUse = false;
	438	}
	439
	440	/**
	441	* Returns a singleton {@code RenderQueue} object used by the rendering
	442	* pipeline.
	443	*
	444	* @return a render queue
	445	* @see RenderQueue
	446	*/
	447	public abstract RenderQueue getRenderQueue();
	448
	449	/**
	450	* Saves the the state of this context.
	451	* It may reset the current context.
	452	*
	453	* Note: must be called while the RenderQueue lock is held.
	454	*
	455	* @see RenderQueue#lock
	456	* @see RenderQueue#unlock
	457	*/
	458	public abstract void saveState();
	459
	460	/**
	461	* Restores the native state of this context.
	462	* It may reset the current context.
	463	*
	464	* Note: must be called while the RenderQueue lock is held.
	465	*
	466	* @see RenderQueue#lock
	467	* @see RenderQueue#unlock
	468	*/
	469	public abstract void restoreState();
	470	}

java/pkg/sun/java2d/pipe/BufferedMaskBlit.java+163−0

@@ -0,0 +1,163 @@
	1	/*
	2	* Copyright (c) 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.java2d.pipe;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.Composite;
	30	import sun.java2d.SurfaceData;
	31	import sun.java2d.loops.Blit;
	32	import sun.java2d.loops.CompositeType;
	33	import sun.java2d.loops.MaskBlit;
	34	import sun.java2d.loops.SurfaceType;
	35	import static sun.java2d.pipe.BufferedOpCodes.*;
	36
	37	/**
	38	* The MaskBlit operation is expressed as:
	39	* dst = ((src <MODE> dst) * pathA) + (dst * (1 - pathA))
	40	*
	41	* The OGL/D3D implementation of the MaskBlit operation differs from the above
	42	* equation because it is not possible to perform such a complex operation in
	43	* OpenGL/Direct3D (without the use of advanced techniques like fragment
	44	* shaders and multitexturing). Therefore, the BufferedMaskBlit operation
	45	* is expressed as:
	46	* dst = (src * pathA) <SrcOver> dst
	47	*
	48	* This simplified formula is only equivalent to the "true" MaskBlit equation
	49	* in the following situations:
	50	* - <MODE> is SrcOver
	51	* - <MODE> is Src, extra alpha == 1.0, and the source surface is opaque
	52	*
	53	* Therefore, we register BufferedMaskBlit primitives for only the SurfaceType
	54	* and CompositeType restrictions mentioned above. In addition for the Src
	55	* case, we must override the composite with a SrcOver (no extra alpha)
	56	* instance, so that we set up the OpenGL/Direct3D blending mode to match the
	57	* BufferedMaskBlit equation.
	58	*/
	59	public abstract class BufferedMaskBlit extends MaskBlit {
	60
	61	private static final int ST_INT_ARGB = 0;
	62	private static final int ST_INT_ARGB_PRE = 1;
	63	private static final int ST_INT_RGB = 2;
	64	private static final int ST_INT_BGR = 3;
	65
	66	private final RenderQueue rq;
	67	private final int srcTypeVal;
	68	private Blit blitop;
	69
	70	protected BufferedMaskBlit(RenderQueue rq,
	71	SurfaceType srcType,
	72	CompositeType compType,
	73	SurfaceType dstType)
	74	{
	75	super(srcType, compType, dstType);
	76	this.rq = rq;
	77	if (srcType == SurfaceType.IntArgb) {
	78	this.srcTypeVal = ST_INT_ARGB;
	79	} else if (srcType == SurfaceType.IntArgbPre) {
	80	this.srcTypeVal = ST_INT_ARGB_PRE;
	81	} else if (srcType == SurfaceType.IntRgb) {
	82	this.srcTypeVal = ST_INT_RGB;
	83	} else if (srcType == SurfaceType.IntBgr) {
	84	this.srcTypeVal = ST_INT_BGR;
	85	} else {
	86	throw new InternalError("unrecognized source surface type");
	87	}
	88	}
	89
	90	@Override
	91	public void MaskBlit(SurfaceData src, SurfaceData dst,
	92	Composite comp, Region clip,
	93	int srcx, int srcy,
	94	int dstx, int dsty,
	95	int width, int height,
	96	byte[] mask, int maskoff, int maskscan)
	97	{
	98	if (width <= 0 \|\| height <= 0) {
	99	return;
	100	}
	101
	102	if (mask == null) {
	103	// no mask involved; delegate to regular blit loop
	104	if (blitop == null) {
	105	blitop = Blit.getFromCache(src.getSurfaceType(),
	106	CompositeType.AnyAlpha,
	107	this.getDestType());
	108	}
	109	blitop.Blit(src, dst,
	110	comp, clip,
	111	srcx, srcy, dstx, dsty,
	112	width, height);
	113	return;
	114	}
	115
	116	AlphaComposite acomp = (AlphaComposite)comp;
	117	if (acomp.getRule() != AlphaComposite.SRC_OVER) {
	118	comp = AlphaComposite.SrcOver;
	119	}
	120
	121	rq.lock();
	122	try {
	123	validateContext(dst, comp, clip);
	124
	125	RenderBuffer buf = rq.getBuffer();
	126	int totalBytesRequired = 20 + (width * height * 4);
	127
	128	/*
	129	* REMIND: we should fix this so that it works with tiles that
	130	* are larger than the entire buffer, but the native
	131	* OGL/D3DMaskBlit isn't even prepared for tiles larger
	132	* than 32x32 pixels, so there's no urgency here...
	133	*/
	134	rq.ensureCapacity(totalBytesRequired);
	135
	136	// enqueue parameters and tile pixels
	137	int newpos = enqueueTile(buf.getAddress(), buf.position(),
	138	src, src.getNativeOps(), srcTypeVal,
	139	mask, mask.length, maskoff, maskscan,
	140	srcx, srcy, dstx, dsty,
	141	width, height);
	142
	143	buf.position(newpos);
	144	} finally {
	145	rq.unlock();
	146	}
	147	}
	148
	149	private native int enqueueTile(long buf, int bpos,
	150	SurfaceData srcData,
	151	long pSrcOps, int srcType,
	152	byte[] mask, int masklen,
	153	int maskoff, int maskscan,
	154	int srcx, int srcy, int dstx, int dsty,
	155	int width, int height);
	156
	157	/**
	158	* Validates the context state using the given destination surface
	159	* and composite/clip values.
	160	*/
	161	protected abstract void validateContext(SurfaceData dstData,
	162	Composite comp, Region clip);
	163	}

java/pkg/sun/java2d/pipe/BufferedMaskFill.java+153−0

@@ -0,0 +1,153 @@
	1	/*
	2	* Copyright (c) 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.java2d.pipe;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.Composite;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.java2d.SurfaceData;
	32	import sun.java2d.loops.CompositeType;
	33	import sun.java2d.loops.MaskFill;
	34	import sun.java2d.loops.SurfaceType;
	35	import static sun.java2d.pipe.BufferedOpCodes.*;
	36
	37	/**
	38	* The MaskFill operation is expressed as:
	39	* dst = ((src <MODE> dst) * pathA) + (dst * (1 - pathA))
	40	*
	41	* The OGL/D3D implementation of the MaskFill operation differs from the above
	42	* equation because it is not possible to perform such a complex operation in
	43	* OpenGL/Direct3D (without the use of advanced techniques like fragment
	44	* shaders and multitexturing). Therefore, the BufferedMaskFill operation
	45	* is expressed as:
	46	* dst = (src * pathA) <SrcOver> dst
	47	*
	48	* This simplified formula is only equivalent to the "true" MaskFill equation
	49	* in the following situations:
	50	* - <MODE> is SrcOver
	51	* - <MODE> is Src, extra alpha == 1.0, and the source paint is opaque
	52	*
	53	* Therefore, we register BufferedMaskFill primitives for only the SurfaceType
	54	* and CompositeType restrictions mentioned above. In addition, for the
	55	* SrcNoEa case we must override the incoming composite with a SrcOver (no
	56	* extra alpha) instance, so that we set up the OpenGL/Direct3D blending
	57	* mode to match the BufferedMaskFill equation.
	58	*/
	59	public abstract class BufferedMaskFill extends MaskFill {
	60
	61	protected final RenderQueue rq;
	62
	63	protected BufferedMaskFill(RenderQueue rq,
	64	SurfaceType srcType,
	65	CompositeType compType,
	66	SurfaceType dstType)
	67	{
	68	super(srcType, compType, dstType);
	69	this.rq = rq;
	70	}
	71
	72	@Override
	73	public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
	74	Composite comp,
	75	final int x, final int y, final int w, final int h,
	76	final byte[] mask,
	77	final int maskoff, final int maskscan)
	78	{
	79	AlphaComposite acomp = (AlphaComposite)comp;
	80	if (acomp.getRule() != AlphaComposite.SRC_OVER) {
	81	comp = AlphaComposite.SrcOver;
	82	}
	83
	84	rq.lock();
	85	try {
	86	validateContext(sg2d, comp, BufferedContext.USE_MASK);
	87
	88	// we adjust the mask length so that the mask ends on a
	89	// 4-byte boundary
	90	int maskBytesRequired;
	91	if (mask != null) {
	92	// we adjust the mask length so that the mask ends on a
	93	// 4-byte boundary
	94	maskBytesRequired = (mask.length + 3) & (~3);
	95	} else {
	96	// mask not needed
	97	maskBytesRequired = 0;
	98	}
	99	int totalBytesRequired = 32 + maskBytesRequired;
	100
	101	RenderBuffer buf = rq.getBuffer();
	102	if (totalBytesRequired <= buf.capacity()) {
	103	if (totalBytesRequired > buf.remaining()) {
	104	// process the queue first and then enqueue the mask
	105	rq.flushNow();
	106	}
	107
	108	buf.putInt(MASK_FILL);
	109	// enqueue parameters
	110	buf.putInt(x).putInt(y).putInt(w).putInt(h);
	111	buf.putInt(maskoff);
	112	buf.putInt(maskscan);
	113	buf.putInt(maskBytesRequired);
	114	if (mask != null) {
	115	// enqueue the mask
	116	int padding = maskBytesRequired - mask.length;
	117	buf.put(mask);
	118	if (padding != 0) {
	119	buf.position(buf.position() + padding);
	120	}
	121	}
	122	} else {
	123	// queue is too small to accomodate entire mask; perform
	124	// the operation directly on the queue flushing thread
	125	rq.flushAndInvokeNow(new Runnable() {
	126	public void run() {
	127	maskFill(x, y, w, h,
	128	maskoff, maskscan, mask.length, mask);
	129	}
	130	});
	131	}
	132	} finally {
	133	rq.unlock();
	134	}
	135	}
	136
	137	/**
	138	* Called as a separate Runnable when the operation is too large to fit
	139	* on the RenderQueue. The OGL/D3D pipelines each have their own (small)
	140	* native implementation of this method.
	141	*/
	142	protected abstract void maskFill(int x, int y, int w, int h,
	143	int maskoff, int maskscan, int masklen,
	144	byte[] mask);
	145
	146	/**
	147	* Validates the state in the provided SunGraphics2D object and sets up
	148	* any special resources for this operation (e.g. enabling gradient
	149	* shading).
	150	*/
	151	protected abstract void validateContext(SunGraphics2D sg2d,
	152	Composite comp, int ctxflags);
	153	}

java/pkg/sun/java2d/pipe/BufferedOpCodes.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedOpCodes.java+99−0

@@ -0,0 +1,99 @@
	1	/*
	2	* Copyright (c) 2005, 2008, 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.java2d.pipe;
	27
	28	public class BufferedOpCodes {
	29	// draw ops
	30	public static final int DRAW_LINE = 10;
	31	public static final int DRAW_RECT = 11;
	32	public static final int DRAW_POLY = 12;
	33	public static final int DRAW_PIXEL = 13;
	34	public static final int DRAW_SCANLINES = 14;
	35	public static final int DRAW_PARALLELOGRAM = 15;
	36	public static final int DRAW_AAPARALLELOGRAM = 16;
	37
	38	// fill ops
	39	public static final int FILL_RECT = 20;
	40	public static final int FILL_SPANS = 21;
	41	public static final int FILL_PARALLELOGRAM = 22;
	42	public static final int FILL_AAPARALLELOGRAM = 23;
	43
	44	// copy-related ops
	45	public static final int COPY_AREA = 30;
	46	public static final int BLIT = 31;
	47	public static final int MASK_FILL = 32;
	48	public static final int MASK_BLIT = 33;
	49	public static final int SURFACE_TO_SW_BLIT = 34;
	50
	51	// text-related ops
	52	public static final int DRAW_GLYPH_LIST = 40;
	53
	54	// state-related ops
	55	public static final int SET_RECT_CLIP = 51;
	56	public static final int BEGIN_SHAPE_CLIP = 52;
	57	public static final int SET_SHAPE_CLIP_SPANS = 53;
	58	public static final int END_SHAPE_CLIP = 54;
	59	public static final int RESET_CLIP = 55;
	60	public static final int SET_ALPHA_COMPOSITE = 56;
	61	public static final int SET_XOR_COMPOSITE = 57;
	62	public static final int RESET_COMPOSITE = 58;
	63	public static final int SET_TRANSFORM = 59;
	64	public static final int RESET_TRANSFORM = 60;
	65
	66	// context-related ops
	67	public static final int SET_SURFACES = 70;
	68	public static final int SET_SCRATCH_SURFACE = 71;
	69	public static final int FLUSH_SURFACE = 72;
	70	public static final int DISPOSE_SURFACE = 73;
	71	public static final int DISPOSE_CONFIG = 74;
	72	public static final int INVALIDATE_CONTEXT = 75;
	73	public static final int SYNC = 76;
	74	public static final int RESTORE_DEVICES = 77;
	75	public static final int SAVE_STATE = 78;
	76	public static final int RESTORE_STATE = 79;
	77
	78	// multibuffering ops
	79	public static final int SWAP_BUFFERS = 80;
	80
	81	// special no-op op code (mainly used for achieving 8-byte alignment)
	82	public static final int NOOP = 90;
	83
	84	// paint-related ops
	85	public static final int RESET_PAINT = 100;
	86	public static final int SET_COLOR = 101;
	87	public static final int SET_GRADIENT_PAINT = 102;
	88	public static final int SET_LINEAR_GRADIENT_PAINT = 103;
	89	public static final int SET_RADIAL_GRADIENT_PAINT = 104;
	90	public static final int SET_TEXTURE_PAINT = 105;
	91
	92	// BufferedImageOp-related ops
	93	public static final int ENABLE_CONVOLVE_OP = 120;
	94	public static final int DISABLE_CONVOLVE_OP = 121;
	95	public static final int ENABLE_RESCALE_OP = 122;
	96	public static final int DISABLE_RESCALE_OP = 123;
	97	public static final int ENABLE_LOOKUP_OP = 124;
	98	public static final int DISABLE_LOOKUP_OP = 125;
	99	}

java/pkg/sun/java2d/pipe/BufferedPaints.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedPaints.java+533−0

@@ -0,0 +1,533 @@
	1	/*
	2	* Copyright (c) 2007, 2010, 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.java2d.pipe;
	27
	28	import java.awt.Color;
	29	import java.awt.GradientPaint;
	30	import java.awt.LinearGradientPaint;
	31	import java.awt.MultipleGradientPaint;
	32	import java.awt.MultipleGradientPaint.ColorSpaceType;
	33	import java.awt.MultipleGradientPaint.CycleMethod;
	34	import java.awt.Paint;
	35	import java.awt.RadialGradientPaint;
	36	import java.awt.TexturePaint;
	37	import java.awt.geom.AffineTransform;
	38	import java.awt.geom.Point2D;
	39	import java.awt.geom.Rectangle2D;
	40	import java.awt.image.AffineTransformOp;
	41	import java.awt.image.BufferedImage;
	42	import sun.awt.image.PixelConverter;
	43	import sun.java2d.SunGraphics2D;
	44	import sun.java2d.SurfaceData;
	45	import sun.java2d.loops.CompositeType;
	46	import sun.java2d.loops.SurfaceType;
	47	import static sun.java2d.pipe.BufferedOpCodes.*;
	48
	49	public class BufferedPaints {
	50
	51	static void setPaint(RenderQueue rq, SunGraphics2D sg2d,
	52	Paint paint, int ctxflags)
	53	{
	54	if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {
	55	setColor(rq, sg2d.pixel);
	56	} else {
	57	boolean useMask = (ctxflags & BufferedContext.USE_MASK) != 0;
	58	switch (sg2d.paintState) {
	59	case SunGraphics2D.PAINT_GRADIENT:
	60	setGradientPaint(rq, sg2d,
	61	(GradientPaint)paint, useMask);
	62	break;
	63	case SunGraphics2D.PAINT_LIN_GRADIENT:
	64	setLinearGradientPaint(rq, sg2d,
	65	(LinearGradientPaint)paint, useMask);
	66	break;
	67	case SunGraphics2D.PAINT_RAD_GRADIENT:
	68	setRadialGradientPaint(rq, sg2d,
	69	(RadialGradientPaint)paint, useMask);
	70	break;
	71	case SunGraphics2D.PAINT_TEXTURE:
	72	setTexturePaint(rq, sg2d,
	73	(TexturePaint)paint, useMask);
	74	break;
	75	default:
	76	break;
	77	}
	78	}
	79	}
	80
	81	static void resetPaint(RenderQueue rq) {
	82	// assert rq.lock.isHeldByCurrentThread();
	83	rq.ensureCapacity(4);
	84	RenderBuffer buf = rq.getBuffer();
	85	buf.putInt(RESET_PAINT);
	86	}
	87
	88	/**************************** Color support *****************************/
	89
	90	private static void setColor(RenderQueue rq, int pixel) {
	91	// assert rq.lock.isHeldByCurrentThread();
	92	rq.ensureCapacity(8);
	93	RenderBuffer buf = rq.getBuffer();
	94	buf.putInt(SET_COLOR);
	95	buf.putInt(pixel);
	96	}
	97
	98	/*********************** GradientPaint support **************************/
	99
	100	/**
	101	* Note: This code is factored out into a separate static method
	102	* so that it can be shared by both the Gradient and LinearGradient
	103	* implementations. LinearGradient uses this code (for the
	104	* two-color sRGB case only) because it can be much faster than the
	105	* equivalent implementation that uses fragment shaders.
	106	*
	107	* We use OpenGL's texture coordinate generator to automatically
	108	* apply a smooth gradient (either cyclic or acyclic) to the geometry
	109	* being rendered. This technique is almost identical to the one
	110	* described in the comments for BufferedPaints.setTexturePaint(),
	111	* except the calculations take place in one dimension instead of two.
	112	* Instead of an anchor rectangle in the TexturePaint case, we use
	113	* the vector between the two GradientPaint end points in our
	114	* calculations. The generator uses a single plane equation that
	115	* takes the (x,y) location (in device space) of the fragment being
	116	* rendered to calculate a (u) texture coordinate for that fragment:
	117	* u = Ax + By + Cz + Dw
	118	*
	119	* The gradient renderer uses a two-pixel 1D texture where the first
	120	* pixel contains the first GradientPaint color, and the second pixel
	121	* contains the second GradientPaint color. (Note that we use the
	122	* GL_CLAMP_TO_EDGE wrapping mode for acyclic gradients so that we
	123	* clamp the colors properly at the extremes.) The following diagram
	124	* attempts to show the layout of the texture containing the two
	125	* GradientPaint colors (C1 and C2):
	126	*
	127	* +-----------------+
	128	* \| C1 \| C2 \|
	129	* \| \| \|
	130	* +-----------------+
	131	* u=0 .25 .5 .75 1
	132	*
	133	* We calculate our plane equation constants (A,B,D) such that u=0.25
	134	* corresponds to the first GradientPaint end point in user space and
	135	* u=0.75 corresponds to the second end point. This is somewhat
	136	* non-obvious, but since the gradient colors are generated by
	137	* interpolating between C1 and C2, we want the pure color at the
	138	* end points, and we will get the pure color only when u correlates
	139	* to the center of a texel. The following chart shows the expected
	140	* color for some sample values of u (where C' is the color halfway
	141	* between C1 and C2):
	142	*
	143	* u value acyclic (GL_CLAMP) cyclic (GL_REPEAT)
	144	* ------- ------------------ ------------------
	145	* -0.25 C1 C2
	146	* 0.0 C1 C'
	147	* 0.25 C1 C1
	148	* 0.5 C' C'
	149	* 0.75 C2 C2
	150	* 1.0 C2 C'
	151	* 1.25 C2 C1
	152	*
	153	* Original inspiration for this technique came from UMD's Agile2D
	154	* project (GradientManager.java).
	155	*/
	156	private static void setGradientPaint(RenderQueue rq, AffineTransform at,
	157	Color c1, Color c2,
	158	Point2D pt1, Point2D pt2,
	159	boolean isCyclic, boolean useMask)
	160	{
	161	// convert gradient colors to IntArgbPre format
	162	PixelConverter pc = PixelConverter.ArgbPre.instance;
	163	int pixel1 = pc.rgbToPixel(c1.getRGB(), null);
	164	int pixel2 = pc.rgbToPixel(c2.getRGB(), null);
	165
	166	// calculate plane equation constants
	167	double x = pt1.getX();
	168	double y = pt1.getY();
	169	at.translate(x, y);
	170	// now gradient point 1 is at the origin
	171	x = pt2.getX() - x;
	172	y = pt2.getY() - y;
	173	double len = Math.sqrt(x * x + y * y);
	174	at.rotate(x, y);
	175	// now gradient point 2 is on the positive x-axis
	176	at.scale(2*len, 1);
	177	// now gradient point 2 is at (0.5, 0)
	178	at.translate(-0.25, 0);
	179	// now gradient point 1 is at (0.25, 0), point 2 is at (0.75, 0)
	180
	181	double p0, p1, p3;
	182	try {
	183	at.invert();
	184	p0 = at.getScaleX();
	185	p1 = at.getShearX();
	186	p3 = at.getTranslateX();
	187	} catch (java.awt.geom.NoninvertibleTransformException e) {
	188	p0 = p1 = p3 = 0.0;
	189	}
	190
	191	// assert rq.lock.isHeldByCurrentThread();
	192	rq.ensureCapacityAndAlignment(44, 12);
	193	RenderBuffer buf = rq.getBuffer();
	194	buf.putInt(SET_GRADIENT_PAINT);
	195	buf.putInt(useMask ? 1 : 0);
	196	buf.putInt(isCyclic ? 1 : 0);
	197	buf.putDouble(p0).putDouble(p1).putDouble(p3);
	198	buf.putInt(pixel1).putInt(pixel2);
	199	}
	200
	201	private static void setGradientPaint(RenderQueue rq,
	202	SunGraphics2D sg2d,
	203	GradientPaint paint,
	204	boolean useMask)
	205	{
	206	setGradientPaint(rq, (AffineTransform)sg2d.transform.clone(),
	207	paint.getColor1(), paint.getColor2(),
	208	paint.getPoint1(), paint.getPoint2(),
	209	paint.isCyclic(), useMask);
	210	}
	211
	212	/************************ TexturePaint support **************************/
	213
	214	/**
	215	* We use OpenGL's texture coordinate generator to automatically
	216	* map the TexturePaint image to the geometry being rendered. The
	217	* generator uses two separate plane equations that take the (x,y)
	218	* location (in device space) of the fragment being rendered to
	219	* calculate (u,v) texture coordinates for that fragment:
	220	* u = Ax + By + Cz + Dw
	221	* v = Ex + Fy + Gz + Hw
	222	*
	223	* Since we use a 2D orthographic projection, we can assume that z=0
	224	* and w=1 for any fragment. So we need to calculate appropriate
	225	* values for the plane equation constants (A,B,D) and (E,F,H) such
	226	* that {u,v}=0 for the top-left of the TexturePaint's anchor
	227	* rectangle and {u,v}=1 for the bottom-right of the anchor rectangle.
	228	* We can easily make the texture image repeat for {u,v} values
	229	* outside the range [0,1] by specifying the GL_REPEAT texture wrap
	230	* mode.
	231	*
	232	* Calculating the plane equation constants is surprisingly simple.
	233	* We can think of it as an inverse matrix operation that takes
	234	* device space coordinates and transforms them into user space
	235	* coordinates that correspond to a location relative to the anchor
	236	* rectangle. First, we translate and scale the current user space
	237	* transform by applying the anchor rectangle bounds. We then take
	238	* the inverse of this affine transform. The rows of the resulting
	239	* inverse matrix correlate nicely to the plane equation constants
	240	* we were seeking.
	241	*/
	242	private static void setTexturePaint(RenderQueue rq,
	243	SunGraphics2D sg2d,
	244	TexturePaint paint,
	245	boolean useMask)
	246	{
	247	BufferedImage bi = paint.getImage();
	248	SurfaceData dstData = sg2d.surfaceData;
	249	SurfaceData srcData =
	250	dstData.getSourceSurfaceData(bi, sg2d.TRANSFORM_ISIDENT,
	251	CompositeType.SrcOver, null);
	252	boolean filter =
	253	(sg2d.interpolationType !=
	254	AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
	255
	256	// calculate plane equation constants
	257	AffineTransform at = (AffineTransform)sg2d.transform.clone();
	258	Rectangle2D anchor = paint.getAnchorRect();
	259	at.translate(anchor.getX(), anchor.getY());
	260	at.scale(anchor.getWidth(), anchor.getHeight());
	261
	262	double xp0, xp1, xp3, yp0, yp1, yp3;
	263	try {
	264	at.invert();
	265	xp0 = at.getScaleX();
	266	xp1 = at.getShearX();
	267	xp3 = at.getTranslateX();
	268	yp0 = at.getShearY();
	269	yp1 = at.getScaleY();
	270	yp3 = at.getTranslateY();
	271	} catch (java.awt.geom.NoninvertibleTransformException e) {
	272	xp0 = xp1 = xp3 = yp0 = yp1 = yp3 = 0.0;
	273	}
	274
	275	// assert rq.lock.isHeldByCurrentThread();
	276	rq.ensureCapacityAndAlignment(68, 12);
	277	RenderBuffer buf = rq.getBuffer();
	278	buf.putInt(SET_TEXTURE_PAINT);
	279	buf.putInt(useMask ? 1 : 0);
	280	buf.putInt(filter ? 1 : 0);
	281	buf.putLong(srcData.getNativeOps());
	282	buf.putDouble(xp0).putDouble(xp1).putDouble(xp3);
	283	buf.putDouble(yp0).putDouble(yp1).putDouble(yp3);
	284	}
	285
	286	/**************** Shared MultipleGradientPaint support ******************/
	287
	288	/**
	289	* The maximum number of gradient "stops" supported by our native
	290	* fragment shader implementations.
	291	*
	292	* This value has been empirically determined and capped to allow
	293	* our native shaders to run on all shader-level graphics hardware,
	294	* even on the older, more limited GPUs. Even the oldest Nvidia
	295	* hardware could handle 16, or even 32 fractions without any problem.
	296	* But the first-generation boards from ATI would fall back into
	297	* software mode (which is unusably slow) for values larger than 12;
	298	* it appears that those boards do not have enough native registers
	299	* to support the number of array accesses required by our gradient
	300	* shaders. So for now we will cap this value at 12, but we can
	301	* re-evaluate this in the future as hardware becomes more capable.
	302	*/
	303	public static final int MULTI_MAX_FRACTIONS = 12;
	304
	305	/**
	306	* Helper function to convert a color component in sRGB space to
	307	* linear RGB space. Copied directly from the
	308	* MultipleGradientPaintContext class.
	309	*/
	310	public static int convertSRGBtoLinearRGB(int color) {
	311	float input, output;
	312
	313	input = color / 255.0f;
	314	if (input <= 0.04045f) {
	315	output = input / 12.92f;
	316	} else {
	317	output = (float)Math.pow((input + 0.055) / 1.055, 2.4);
	318	}
	319
	320	return Math.round(output * 255.0f);
	321	}
	322
	323	/**
	324	* Helper function to convert a (non-premultiplied) Color in sRGB
	325	* space to an IntArgbPre pixel value, optionally in linear RGB space.
	326	* Based on the PixelConverter.ArgbPre.rgbToPixel() method.
	327	*/
	328	private static int colorToIntArgbPrePixel(Color c, boolean linear) {
	329	int rgb = c.getRGB();
	330	if (!linear && ((rgb >> 24) == -1)) {
	331	return rgb;
	332	}
	333	int a = rgb >>> 24;
	334	int r = (rgb >> 16) & 0xff;
	335	int g = (rgb >> 8) & 0xff;
	336	int b = (rgb ) & 0xff;
	337	if (linear) {
	338	r = convertSRGBtoLinearRGB(r);
	339	g = convertSRGBtoLinearRGB(g);
	340	b = convertSRGBtoLinearRGB(b);
	341	}
	342	int a2 = a + (a >> 7);
	343	r = (r * a2) >> 8;
	344	g = (g * a2) >> 8;
	345	b = (b * a2) >> 8;
	346	return ((a << 24) \| (r << 16) \| (g << 8) \| (b));
	347	}
	348
	349	/**
	350	* Converts the given array of Color objects into an int array
	351	* containing IntArgbPre pixel values. If the linear parameter
	352	* is true, the Color values will be converted into a linear RGB
	353	* color space before being returned.
	354	*/
	355	private static int[] convertToIntArgbPrePixels(Color[] colors,
	356	boolean linear)
	357	{
	358	int[] pixels = new int[colors.length];
	359	for (int i = 0; i < colors.length; i++) {
	360	pixels[i] = colorToIntArgbPrePixel(colors[i], linear);
	361	}
	362	return pixels;
	363	}
	364
	365	/******************** LinearGradientPaint support ***********************/
	366
	367	/**
	368	* This method uses techniques that are nearly identical to those
	369	* employed in setGradientPaint() above. The primary difference
	370	* is that at the native level we use a fragment shader to manually
	371	* apply the plane equation constants to the current fragment position
	372	* to calculate the gradient position in the range [0,1] (the native
	373	* code for GradientPaint does the same, except that it uses OpenGL's
	374	* automatic texture coordinate generation facilities).
	375	*
	376	* One other minor difference worth mentioning is that
	377	* setGradientPaint() calculates the plane equation constants
	378	* such that the gradient end points are positioned at 0.25 and 0.75
	379	* (for reasons discussed in the comments for that method). In
	380	* contrast, for LinearGradientPaint we setup the equation constants
	381	* such that the gradient end points fall at 0.0 and 1.0. The
	382	* reason for this difference is that in the fragment shader we
	383	* have more control over how the gradient values are interpreted
	384	* (depending on the paint's CycleMethod).
	385	*/
	386	private static void setLinearGradientPaint(RenderQueue rq,
	387	SunGraphics2D sg2d,
	388	LinearGradientPaint paint,
	389	boolean useMask)
	390	{
	391	boolean linear =
	392	(paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
	393	Color[] colors = paint.getColors();
	394	int numStops = colors.length;
	395	Point2D pt1 = paint.getStartPoint();
	396	Point2D pt2 = paint.getEndPoint();
	397	AffineTransform at = paint.getTransform();
	398	at.preConcatenate(sg2d.transform);
	399
	400	if (!linear && numStops == 2 &&
	401	paint.getCycleMethod() != CycleMethod.REPEAT)
	402	{
	403	// delegate to the optimized two-color gradient codepath
	404	boolean isCyclic =
	405	(paint.getCycleMethod() != CycleMethod.NO_CYCLE);
	406	setGradientPaint(rq, at,
	407	colors[0], colors[1],
	408	pt1, pt2,
	409	isCyclic, useMask);
	410	return;
	411	}
	412
	413	int cycleMethod = paint.getCycleMethod().ordinal();
	414	float[] fractions = paint.getFractions();
	415	int[] pixels = convertToIntArgbPrePixels(colors, linear);
	416
	417	// calculate plane equation constants
	418	double x = pt1.getX();
	419	double y = pt1.getY();
	420	at.translate(x, y);
	421	// now gradient point 1 is at the origin
	422	x = pt2.getX() - x;
	423	y = pt2.getY() - y;
	424	double len = Math.sqrt(x * x + y * y);
	425	at.rotate(x, y);
	426	// now gradient point 2 is on the positive x-axis
	427	at.scale(len, 1);
	428	// now gradient point 1 is at (0.0, 0), point 2 is at (1.0, 0)
	429
	430	float p0, p1, p3;
	431	try {
	432	at.invert();
	433	p0 = (float)at.getScaleX();
	434	p1 = (float)at.getShearX();
	435	p3 = (float)at.getTranslateX();
	436	} catch (java.awt.geom.NoninvertibleTransformException e) {
	437	p0 = p1 = p3 = 0.0f;
	438	}
	439
	440	// assert rq.lock.isHeldByCurrentThread();
	441	rq.ensureCapacity(20 + 12 + (numStops42));
	442	RenderBuffer buf = rq.getBuffer();
	443	buf.putInt(SET_LINEAR_GRADIENT_PAINT);
	444	buf.putInt(useMask ? 1 : 0);
	445	buf.putInt(linear ? 1 : 0);
	446	buf.putInt(cycleMethod);
	447	buf.putInt(numStops);
	448	buf.putFloat(p0);
	449	buf.putFloat(p1);
	450	buf.putFloat(p3);
	451	buf.put(fractions);
	452	buf.put(pixels);
	453	}
	454
	455	/******************** RadialGradientPaint support ***********************/
	456
	457	/**
	458	* This method calculates six m** values and a focusX value that
	459	* are used by the native fragment shader. These techniques are
	460	* based on a whitepaper by Daniel Rice on radial gradient performance
	461	* (attached to the bug report for 6521533). One can refer to that
	462	* document for the complete set of formulas and calculations, but
	463	* the basic goal is to compose a transform that will convert an
	464	* (x,y) position in device space into a "u" value that represents
	465	* the relative distance to the gradient focus point. The resulting
	466	* value can be used to look up the appropriate color by linearly
	467	* interpolating between the two nearest colors in the gradient.
	468	*/
	469	private static void setRadialGradientPaint(RenderQueue rq,
	470	SunGraphics2D sg2d,
	471	RadialGradientPaint paint,
	472	boolean useMask)
	473	{
	474	boolean linear =
	475	(paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
	476	int cycleMethod = paint.getCycleMethod().ordinal();
	477	float[] fractions = paint.getFractions();
	478	Color[] colors = paint.getColors();
	479	int numStops = colors.length;
	480	int[] pixels = convertToIntArgbPrePixels(colors, linear);
	481	Point2D center = paint.getCenterPoint();
	482	Point2D focus = paint.getFocusPoint();
	483	float radius = paint.getRadius();
	484
	485	// save original (untransformed) center and focus points
	486	double cx = center.getX();
	487	double cy = center.getY();
	488	double fx = focus.getX();
	489	double fy = focus.getY();
	490
	491	// transform from gradient coords to device coords
	492	AffineTransform at = paint.getTransform();
	493	at.preConcatenate(sg2d.transform);
	494	focus = at.transform(focus, focus);
	495
	496	// transform unit circle to gradient coords; we start with the
	497	// unit circle (center=(0,0), focus on positive x-axis, radius=1)
	498	// and then transform into gradient space
	499	at.translate(cx, cy);
	500	at.rotate(fx - cx, fy - cy);
	501	at.scale(radius, radius);
	502
	503	// invert to get mapping from device coords to unit circle
	504	try {
	505	at.invert();
	506	} catch (Exception e) {
	507	at.setToScale(0.0, 0.0);
	508	}
	509	focus = at.transform(focus, focus);
	510
	511	// clamp the focus point so that it does not rest on, or outside
	512	// of, the circumference of the gradient circle
	513	fx = Math.min(focus.getX(), 0.99);
	514
	515	// assert rq.lock.isHeldByCurrentThread();
	516	rq.ensureCapacity(20 + 28 + (numStops42));
	517	RenderBuffer buf = rq.getBuffer();
	518	buf.putInt(SET_RADIAL_GRADIENT_PAINT);
	519	buf.putInt(useMask ? 1 : 0);
	520	buf.putInt(linear ? 1 : 0);
	521	buf.putInt(numStops);
	522	buf.putInt(cycleMethod);
	523	buf.putFloat((float)at.getScaleX());
	524	buf.putFloat((float)at.getShearX());
	525	buf.putFloat((float)at.getTranslateX());
	526	buf.putFloat((float)at.getShearY());
	527	buf.putFloat((float)at.getScaleY());
	528	buf.putFloat((float)at.getTranslateY());
	529	buf.putFloat((float)fx);
	530	buf.put(fractions);
	531	buf.put(pixels);
	532	}
	533	}

java/pkg/sun/java2d/pipe/BufferedRenderPipe$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedRenderPipe$AAParallelogramPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedRenderPipe$BufferedDrawHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedRenderPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/BufferedRenderPipe.java+601−0

@@ -0,0 +1,601 @@
	1	/*
	2	* Copyright (c) 2005, 2008, 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.java2d.pipe;
	27
	28	import java.awt.BasicStroke;
	29	import java.awt.Polygon;
	30	import java.awt.Shape;
	31	import java.awt.geom.AffineTransform;
	32	import java.awt.geom.Arc2D;
	33	import java.awt.geom.Ellipse2D;
	34	import java.awt.geom.Path2D;
	35	import java.awt.geom.IllegalPathStateException;
	36	import java.awt.geom.PathIterator;
	37	import java.awt.geom.Rectangle2D;
	38	import java.awt.geom.RoundRectangle2D;
	39	import sun.java2d.SunGraphics2D;
	40	import sun.java2d.loops.ProcessPath;
	41	import static sun.java2d.pipe.BufferedOpCodes.*;
	42
	43	/**
	44	* Base class for enqueuing rendering operations in a single-threaded
	45	* rendering environment. Instead of each operation being rendered
	46	* immediately by the underlying graphics library, the operation will be
	47	* added to the provided RenderQueue, which will be processed at a later
	48	* time by a single thread.
	49	*
	50	* This class provides implementations of drawLine(), drawRect(), drawPoly(),
	51	* fillRect(), draw(Shape), and fill(Shape), which are useful for a
	52	* hardware-accelerated renderer. The other draw() and fill() methods
	53	* simply delegate to draw(Shape) and fill(Shape), respectively.
	54	*/
	55	public abstract class BufferedRenderPipe
	56	implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe, ParallelogramPipe
	57	{
	58	ParallelogramPipe aapgrampipe = new AAParallelogramPipe();
	59
	60	static final int BYTES_PER_POLY_POINT = 8;
	61	static final int BYTES_PER_SCANLINE = 12;
	62	static final int BYTES_PER_SPAN = 16;
	63
	64	protected RenderQueue rq;
	65	protected RenderBuffer buf;
	66	private BufferedDrawHandler drawHandler;
	67
	68	public BufferedRenderPipe(RenderQueue rq) {
	69	this.rq = rq;
	70	this.buf = rq.getBuffer();
	71	this.drawHandler = new BufferedDrawHandler();
	72	}
	73
	74	public ParallelogramPipe getAAParallelogramPipe() {
	75	return aapgrampipe;
	76	}
	77
	78	/**
	79	* Validates the state in the provided SunGraphics2D object and sets up
	80	* any special resources for this operation (e.g. enabling gradient
	81	* shading).
	82	*/
	83	protected abstract void validateContext(SunGraphics2D sg2d);
	84	protected abstract void validateContextAA(SunGraphics2D sg2d);
	85
	86	public void drawLine(SunGraphics2D sg2d,
	87	int x1, int y1, int x2, int y2)
	88	{
	89	int transx = sg2d.transX;
	90	int transy = sg2d.transY;
	91	rq.lock();
	92	try {
	93	validateContext(sg2d);
	94	rq.ensureCapacity(20);
	95	buf.putInt(DRAW_LINE);
	96	buf.putInt(x1 + transx);
	97	buf.putInt(y1 + transy);
	98	buf.putInt(x2 + transx);
	99	buf.putInt(y2 + transy);
	100	} finally {
	101	rq.unlock();
	102	}
	103	}
	104
	105	public void drawRect(SunGraphics2D sg2d,
	106	int x, int y, int width, int height)
	107	{
	108	rq.lock();
	109	try {
	110	validateContext(sg2d);
	111	rq.ensureCapacity(20);
	112	buf.putInt(DRAW_RECT);
	113	buf.putInt(x + sg2d.transX);
	114	buf.putInt(y + sg2d.transY);
	115	buf.putInt(width);
	116	buf.putInt(height);
	117	} finally {
	118	rq.unlock();
	119	}
	120	}
	121
	122	public void fillRect(SunGraphics2D sg2d,
	123	int x, int y, int width, int height)
	124	{
	125	rq.lock();
	126	try {
	127	validateContext(sg2d);
	128	rq.ensureCapacity(20);
	129	buf.putInt(FILL_RECT);
	130	buf.putInt(x + sg2d.transX);
	131	buf.putInt(y + sg2d.transY);
	132	buf.putInt(width);
	133	buf.putInt(height);
	134	} finally {
	135	rq.unlock();
	136	}
	137	}
	138
	139	public void drawRoundRect(SunGraphics2D sg2d,
	140	int x, int y, int width, int height,
	141	int arcWidth, int arcHeight)
	142	{
	143	draw(sg2d, new RoundRectangle2D.Float(x, y, width, height,
	144	arcWidth, arcHeight));
	145	}
	146
	147	public void fillRoundRect(SunGraphics2D sg2d,
	148	int x, int y, int width, int height,
	149	int arcWidth, int arcHeight)
	150	{
	151	fill(sg2d, new RoundRectangle2D.Float(x, y, width, height,
	152	arcWidth, arcHeight));
	153	}
	154
	155	public void drawOval(SunGraphics2D sg2d,
	156	int x, int y, int width, int height)
	157	{
	158	draw(sg2d, new Ellipse2D.Float(x, y, width, height));
	159	}
	160
	161	public void fillOval(SunGraphics2D sg2d,
	162	int x, int y, int width, int height)
	163	{
	164	fill(sg2d, new Ellipse2D.Float(x, y, width, height));
	165	}
	166
	167	public void drawArc(SunGraphics2D sg2d,
	168	int x, int y, int width, int height,
	169	int startAngle, int arcAngle)
	170	{
	171	draw(sg2d, new Arc2D.Float(x, y, width, height,
	172	startAngle, arcAngle,
	173	Arc2D.OPEN));
	174	}
	175
	176	public void fillArc(SunGraphics2D sg2d,
	177	int x, int y, int width, int height,
	178	int startAngle, int arcAngle)
	179	{
	180	fill(sg2d, new Arc2D.Float(x, y, width, height,
	181	startAngle, arcAngle,
	182	Arc2D.PIE));
	183	}
	184
	185	protected void drawPoly(final SunGraphics2D sg2d,
	186	final int[] xPoints, final int[] yPoints,
	187	final int nPoints, final boolean isClosed)
	188	{
	189	if (xPoints == null \|\| yPoints == null) {
	190	throw new NullPointerException("coordinate array");
	191	}
	192	if (xPoints.length < nPoints \|\| yPoints.length < nPoints) {
	193	throw new ArrayIndexOutOfBoundsException("coordinate array");
	194	}
	195
	196	if (nPoints < 2) {
	197	// render nothing
	198	return;
	199	} else if (nPoints == 2 && !isClosed) {
	200	// render a simple line
	201	drawLine(sg2d, xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
	202	return;
	203	}
	204
	205	rq.lock();
	206	try {
	207	validateContext(sg2d);
	208
	209	int pointBytesRequired = nPoints * BYTES_PER_POLY_POINT;
	210	int totalBytesRequired = 20 + pointBytesRequired;
	211
	212	if (totalBytesRequired <= buf.capacity()) {
	213	if (totalBytesRequired > buf.remaining()) {
	214	// process the queue first and then enqueue the points
	215	rq.flushNow();
	216	}
	217	buf.putInt(DRAW_POLY);
	218	// enqueue parameters
	219	buf.putInt(nPoints);
	220	buf.putInt(isClosed ? 1 : 0);
	221	buf.putInt(sg2d.transX);
	222	buf.putInt(sg2d.transY);
	223	// enqueue the points
	224	buf.put(xPoints, 0, nPoints);
	225	buf.put(yPoints, 0, nPoints);
	226	} else {
	227	// queue is too small to accomodate all points; perform the
	228	// operation directly on the queue flushing thread
	229	rq.flushAndInvokeNow(new Runnable() {
	230	public void run() {
	231	drawPoly(xPoints, yPoints,
	232	nPoints, isClosed,
	233	sg2d.transX, sg2d.transY);
	234	}
	235	});
	236	}
	237	} finally {
	238	rq.unlock();
	239	}
	240	}
	241
	242	protected abstract void drawPoly(int[] xPoints, int[] yPoints,
	243	int nPoints, boolean isClosed,
	244	int transX, int transY);
	245
	246	public void drawPolyline(SunGraphics2D sg2d,
	247	int[] xPoints, int[] yPoints,
	248	int nPoints)
	249	{
	250	drawPoly(sg2d, xPoints, yPoints, nPoints, false);
	251	}
	252
	253	public void drawPolygon(SunGraphics2D sg2d,
	254	int[] xPoints, int[] yPoints,
	255	int nPoints)
	256	{
	257	drawPoly(sg2d, xPoints, yPoints, nPoints, true);
	258	}
	259
	260	public void fillPolygon(SunGraphics2D sg2d,
	261	int[] xPoints, int[] yPoints,
	262	int nPoints)
	263	{
	264	fill(sg2d, new Polygon(xPoints, yPoints, nPoints));
	265	}
	266
	267	private class BufferedDrawHandler
	268	extends ProcessPath.DrawHandler
	269	{
	270	BufferedDrawHandler() {
	271	// these are bogus values; the caller will use validate()
	272	// to ensure that they are set properly prior to each usage
	273	super(0, 0, 0, 0);
	274	}
	275
	276	/**
	277	* This method needs to be called prior to each draw/fillPath()
	278	* operation to ensure the clip bounds are up to date.
	279	*/
	280	void validate(SunGraphics2D sg2d) {
	281	Region clip = sg2d.getCompClip();
	282	setBounds(clip.getLoX(), clip.getLoY(),
	283	clip.getHiX(), clip.getHiY(),
	284	sg2d.strokeHint);
	285	}
	286
	287	/**
	288	* drawPath() support...
	289	*/
	290
	291	public void drawLine(int x1, int y1, int x2, int y2) {
	292	// assert rq.lock.isHeldByCurrentThread();
	293	rq.ensureCapacity(20);
	294	buf.putInt(DRAW_LINE);
	295	buf.putInt(x1);
	296	buf.putInt(y1);
	297	buf.putInt(x2);
	298	buf.putInt(y2);
	299	}
	300
	301	public void drawPixel(int x, int y) {
	302	// assert rq.lock.isHeldByCurrentThread();
	303	rq.ensureCapacity(12);
	304	buf.putInt(DRAW_PIXEL);
	305	buf.putInt(x);
	306	buf.putInt(y);
	307	}
	308
	309	/**
	310	* fillPath() support...
	311	*/
	312
	313	private int scanlineCount;
	314	private int scanlineCountIndex;
	315	private int remainingScanlines;
	316
	317	private void resetFillPath() {
	318	buf.putInt(DRAW_SCANLINES);
	319	scanlineCountIndex = buf.position();
	320	buf.putInt(0);
	321	scanlineCount = 0;
	322	remainingScanlines = buf.remaining() / BYTES_PER_SCANLINE;
	323	}
	324
	325	private void updateScanlineCount() {
	326	buf.putInt(scanlineCountIndex, scanlineCount);
	327	}
	328
	329	/**
	330	* Called from fillPath() to indicate that we are about to
	331	* start issuing drawScanline() calls.
	332	*/
	333	public void startFillPath() {
	334	rq.ensureCapacity(20); // to ensure room for at least a scanline
	335	resetFillPath();
	336	}
	337
	338	public void drawScanline(int x1, int x2, int y) {
	339	if (remainingScanlines == 0) {
	340	updateScanlineCount();
	341	rq.flushNow();
	342	resetFillPath();
	343	}
	344	buf.putInt(x1);
	345	buf.putInt(x2);
	346	buf.putInt(y);
	347	scanlineCount++;
	348	remainingScanlines--;
	349	}
	350
	351	/**
	352	* Called from fillPath() to indicate that we are done
	353	* issuing drawScanline() calls.
	354	*/
	355	public void endFillPath() {
	356	updateScanlineCount();
	357	}
	358	}
	359
	360	protected void drawPath(SunGraphics2D sg2d,
	361	Path2D.Float p2df, int transx, int transy)
	362	{
	363	rq.lock();
	364	try {
	365	validateContext(sg2d);
	366	drawHandler.validate(sg2d);
	367	ProcessPath.drawPath(drawHandler, p2df, transx, transy);
	368	} finally {
	369	rq.unlock();
	370	}
	371	}
	372
	373	protected void fillPath(SunGraphics2D sg2d,
	374	Path2D.Float p2df, int transx, int transy)
	375	{
	376	rq.lock();
	377	try {
	378	validateContext(sg2d);
	379	drawHandler.validate(sg2d);
	380	drawHandler.startFillPath();
	381	ProcessPath.fillPath(drawHandler, p2df, transx, transy);
	382	drawHandler.endFillPath();
	383	} finally {
	384	rq.unlock();
	385	}
	386	}
	387
	388	private native int fillSpans(RenderQueue rq, long buf,
	389	int pos, int limit,
	390	SpanIterator si, long iterator,
	391	int transx, int transy);
	392
	393	protected void fillSpans(SunGraphics2D sg2d, SpanIterator si,
	394	int transx, int transy)
	395	{
	396	rq.lock();
	397	try {
	398	validateContext(sg2d);
	399	rq.ensureCapacity(24); // so that we have room for at least a span
	400	int newpos = fillSpans(rq, buf.getAddress(),
	401	buf.position(), buf.capacity(),
	402	si, si.getNativeIterator(),
	403	transx, transy);
	404	buf.position(newpos);
	405	} finally {
	406	rq.unlock();
	407	}
	408	}
	409
	410	public void fillParallelogram(SunGraphics2D sg2d,
	411	double ux1, double uy1,
	412	double ux2, double uy2,
	413	double x, double y,
	414	double dx1, double dy1,
	415	double dx2, double dy2)
	416	{
	417	rq.lock();
	418	try {
	419	validateContext(sg2d);
	420	rq.ensureCapacity(28);
	421	buf.putInt(FILL_PARALLELOGRAM);
	422	buf.putFloat((float) x);
	423	buf.putFloat((float) y);
	424	buf.putFloat((float) dx1);
	425	buf.putFloat((float) dy1);
	426	buf.putFloat((float) dx2);
	427	buf.putFloat((float) dy2);
	428	} finally {
	429	rq.unlock();
	430	}
	431	}
	432
	433	public void drawParallelogram(SunGraphics2D sg2d,
	434	double ux1, double uy1,
	435	double ux2, double uy2,
	436	double x, double y,
	437	double dx1, double dy1,
	438	double dx2, double dy2,
	439	double lw1, double lw2)
	440	{
	441	rq.lock();
	442	try {
	443	validateContext(sg2d);
	444	rq.ensureCapacity(36);
	445	buf.putInt(DRAW_PARALLELOGRAM);
	446	buf.putFloat((float) x);
	447	buf.putFloat((float) y);
	448	buf.putFloat((float) dx1);
	449	buf.putFloat((float) dy1);
	450	buf.putFloat((float) dx2);
	451	buf.putFloat((float) dy2);
	452	buf.putFloat((float) lw1);
	453	buf.putFloat((float) lw2);
	454	} finally {
	455	rq.unlock();
	456	}
	457	}
	458
	459	private class AAParallelogramPipe implements ParallelogramPipe {
	460	public void fillParallelogram(SunGraphics2D sg2d,
	461	double ux1, double uy1,
	462	double ux2, double uy2,
	463	double x, double y,
	464	double dx1, double dy1,
	465	double dx2, double dy2)
	466	{
	467	rq.lock();
	468	try {
	469	validateContextAA(sg2d);
	470	rq.ensureCapacity(28);
	471	buf.putInt(FILL_AAPARALLELOGRAM);
	472	buf.putFloat((float) x);
	473	buf.putFloat((float) y);
	474	buf.putFloat((float) dx1);
	475	buf.putFloat((float) dy1);
	476	buf.putFloat((float) dx2);
	477	buf.putFloat((float) dy2);
	478	} finally {
	479	rq.unlock();
	480	}
	481	}
	482
	483	public void drawParallelogram(SunGraphics2D sg2d,
	484	double ux1, double uy1,
	485	double ux2, double uy2,
	486	double x, double y,
	487	double dx1, double dy1,
	488	double dx2, double dy2,
	489	double lw1, double lw2)
	490	{
	491	rq.lock();
	492	try {
	493	validateContextAA(sg2d);
	494	rq.ensureCapacity(36);
	495	buf.putInt(DRAW_AAPARALLELOGRAM);
	496	buf.putFloat((float) x);
	497	buf.putFloat((float) y);
	498	buf.putFloat((float) dx1);
	499	buf.putFloat((float) dy1);
	500	buf.putFloat((float) dx2);
	501	buf.putFloat((float) dy2);
	502	buf.putFloat((float) lw1);
	503	buf.putFloat((float) lw2);
	504	} finally {
	505	rq.unlock();
	506	}
	507	}
	508	}
	509
	510	public void draw(SunGraphics2D sg2d, Shape s) {
	511	if (sg2d.strokeState == sg2d.STROKE_THIN) {
	512	if (s instanceof Polygon) {
	513	if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE) {
	514	Polygon p = (Polygon)s;
	515	drawPolygon(sg2d, p.xpoints, p.ypoints, p.npoints);
	516	return;
	517	}
	518	}
	519	Path2D.Float p2df;
	520	int transx, transy;
	521	if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) {
	522	if (s instanceof Path2D.Float) {
	523	p2df = (Path2D.Float)s;
	524	} else {
	525	p2df = new Path2D.Float(s);
	526	}
	527	transx = sg2d.transX;
	528	transy = sg2d.transY;
	529	} else {
	530	p2df = new Path2D.Float(s, sg2d.transform);
	531	transx = 0;
	532	transy = 0;
	533	}
	534	drawPath(sg2d, p2df, transx, transy);
	535	} else if (sg2d.strokeState < sg2d.STROKE_CUSTOM) {
	536	ShapeSpanIterator si = LoopPipe.getStrokeSpans(sg2d, s);
	537	try {
	538	fillSpans(sg2d, si, 0, 0);
	539	} finally {
	540	si.dispose();
	541	}
	542	} else {
	543	fill(sg2d, sg2d.stroke.createStrokedShape(s));
	544	}
	545	}
	546
	547	public void fill(SunGraphics2D sg2d, Shape s) {
	548	int transx, transy;
	549
	550	if (sg2d.strokeState == sg2d.STROKE_THIN) {
	551	// Here we are able to use fillPath() for
	552	// high-quality fills.
	553	Path2D.Float p2df;
	554	if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) {
	555	if (s instanceof Path2D.Float) {
	556	p2df = (Path2D.Float)s;
	557	} else {
	558	p2df = new Path2D.Float(s);
	559	}
	560	transx = sg2d.transX;
	561	transy = sg2d.transY;
	562	} else {
	563	p2df = new Path2D.Float(s, sg2d.transform);
	564	transx = 0;
	565	transy = 0;
	566	}
	567	fillPath(sg2d, p2df, transx, transy);
	568	return;
	569	}
	570
	571	AffineTransform at;
	572	if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) {
	573	// Transform (translation) will be done by FillSpans (we could
	574	// delegate to fillPolygon() here, but most hardware accelerated
	575	// libraries cannot handle non-convex polygons, so we will use
	576	// the FillSpans approach by default)
	577	at = null;
	578	transx = sg2d.transX;
	579	transy = sg2d.transY;
	580	} else {
	581	// Transform will be done by the PathIterator
	582	at = sg2d.transform;
	583	transx = transy = 0;
	584	}
	585
	586	ShapeSpanIterator ssi = LoopPipe.getFillSSI(sg2d);
	587	try {
	588	// Subtract transx/y from the SSI clip to match the
	589	// (potentially untranslated) geometry fed to it
	590	Region clip = sg2d.getCompClip();
	591	ssi.setOutputAreaXYXY(clip.getLoX() - transx,
	592	clip.getLoY() - transy,
	593	clip.getHiX() - transx,
	594	clip.getHiY() - transy);
	595	ssi.appendPath(s.getPathIterator(at));
	596	fillSpans(sg2d, ssi, transx, transy);
	597	} finally {
	598	ssi.dispose();
	599	}
	600	}
	601	}

java/pkg/sun/java2d/pipe/BufferedTextPipe.java+168−0

@@ -0,0 +1,168 @@
	1	/*
	2	* Copyright (c) 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.java2d.pipe;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.Composite;
	30	import sun.font.GlyphList;
	31	import sun.java2d.SunGraphics2D;
	32	import sun.java2d.SurfaceData;
	33	import static sun.java2d.pipe.BufferedOpCodes.*;
	34
	35	public abstract class BufferedTextPipe extends GlyphListPipe {
	36
	37	private static final int BYTES_PER_GLYPH_IMAGE = 8;
	38	private static final int BYTES_PER_GLYPH_POSITION = 8;
	39
	40	/**
	41	* The following offsets are used to pack the parameters in
	42	* createPackedParams(). (They are also used at the native level when
	43	* unpacking the params.)
	44	*/
	45	private static final int OFFSET_CONTRAST = 8;
	46	private static final int OFFSET_RGBORDER = 2;
	47	private static final int OFFSET_SUBPIXPOS = 1;
	48	private static final int OFFSET_POSITIONS = 0;
	49
	50	/**
	51	* Packs the given parameters into a single int value in order to save
	52	* space on the rendering queue. Note that most of these parameters
	53	* are only used for rendering LCD-optimized text, but conditionalizing
	54	* this work wouldn't make any impact on performance, so we will pack
	55	* those parameters even in the non-LCD case.
	56	*/
	57	private static int createPackedParams(SunGraphics2D sg2d, GlyphList gl) {
	58	return
	59	(((gl.usePositions() ? 1 : 0) << OFFSET_POSITIONS) \|
	60	((gl.isSubPixPos() ? 1 : 0) << OFFSET_SUBPIXPOS) \|
	61	((gl.isRGBOrder() ? 1 : 0) << OFFSET_RGBORDER ) \|
	62	((sg2d.lcdTextContrast & 0xff) << OFFSET_CONTRAST ));
	63	}
	64
	65	protected final RenderQueue rq;
	66
	67	protected BufferedTextPipe(RenderQueue rq) {
	68	this.rq = rq;
	69	}
	70
	71	@Override
	72	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {
	73	/*
	74	* The native drawGlyphList() only works with two composite types:
	75	* - CompositeType.SrcOver (with any extra alpha), or
	76	* - CompositeType.Xor
	77	*/
	78	Composite comp = sg2d.composite;
	79	if (comp == AlphaComposite.Src) {
	80	/*
	81	* In addition to the composite types listed above, the logic
	82	* in OGL/D3DSurfaceData.validatePipe() allows for
	83	* CompositeType.SrcNoEa, but only in the presence of an opaque
	84	* color. If we reach this case, we know the color is opaque,
	85	* and therefore SrcNoEa is the same as SrcOverNoEa, so we
	86	* override the composite here.
	87	*/
	88	comp = AlphaComposite.SrcOver;
	89	}
	90
	91	rq.lock();
	92	try {
	93	validateContext(sg2d, comp);
	94	enqueueGlyphList(sg2d, gl);
	95	} finally {
	96	rq.unlock();
	97	}
	98	}
	99
	100	private void enqueueGlyphList(final SunGraphics2D sg2d,
	101	final GlyphList gl)
	102	{
	103	// assert rq.lock.isHeldByCurrentThread();
	104	RenderBuffer buf = rq.getBuffer();
	105	final int totalGlyphs = gl.getNumGlyphs();
	106	int glyphBytesRequired = totalGlyphs * BYTES_PER_GLYPH_IMAGE;
	107	int posBytesRequired =
	108	gl.usePositions() ? totalGlyphs * BYTES_PER_GLYPH_POSITION : 0;
	109	int totalBytesRequired = 24 + glyphBytesRequired + posBytesRequired;
	110
	111	final long[] images = gl.getImages();
	112	final float glyphListOrigX = gl.getX() + 0.5f;
	113	final float glyphListOrigY = gl.getY() + 0.5f;
	114
	115	// make sure the RenderQueue keeps a hard reference to the FontStrike
	116	// so that the associated glyph images are not disposed while enqueued
	117	rq.addReference(gl.getStrike());
	118
	119	if (totalBytesRequired <= buf.capacity()) {
	120	if (totalBytesRequired > buf.remaining()) {
	121	// process the queue first and then enqueue the glyphs
	122	rq.flushNow();
	123	}
	124	rq.ensureAlignment(20);
	125	buf.putInt(DRAW_GLYPH_LIST);
	126	// enqueue parameters
	127	buf.putInt(totalGlyphs);
	128	buf.putInt(createPackedParams(sg2d, gl));
	129	buf.putFloat(glyphListOrigX);
	130	buf.putFloat(glyphListOrigY);
	131	// now enqueue glyph information
	132	buf.put(images, 0, totalGlyphs);
	133	if (gl.usePositions()) {
	134	float[] positions = gl.getPositions();
	135	buf.put(positions, 0, 2*totalGlyphs);
	136	}
	137	} else {
	138	// queue is too small to accomodate glyphs; perform
	139	// the operation directly on the queue flushing thread
	140	rq.flushAndInvokeNow(new Runnable() {
	141	public void run() {
	142	drawGlyphList(totalGlyphs, gl.usePositions(),
	143	gl.isSubPixPos(), gl.isRGBOrder(),
	144	sg2d.lcdTextContrast,
	145	glyphListOrigX, glyphListOrigY,
	146	images, gl.getPositions());
	147	}
	148	});
	149	}
	150	}
	151
	152	/**
	153	* Called as a separate Runnable when the operation is too large to fit
	154	* on the RenderQueue. The OGL/D3D pipelines each have their own (small)
	155	* native implementation of this method.
	156	*/
	157	protected abstract void drawGlyphList(int numGlyphs, boolean usePositions,
	158	boolean subPixPos, boolean rgbOrder,
	159	int lcdContrast,
	160	float glOrigX, float glOrigY,
	161	long[] images, float[] positions);
	162
	163	/**
	164	* Validates the state in the provided SunGraphics2D object.
	165	*/
	166	protected abstract void validateContext(SunGraphics2D sg2d,
	167	Composite comp);
	168	}

java/pkg/sun/java2d/pipe/CompositePipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/CompositePipe.java+50−0

@@ -0,0 +1,50 @@
	1	/*
	2	* Copyright (c) 1997, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.Shape;
	30	import sun.java2d.SunGraphics2D;
	31
	32	/**
	33	* This interface defines the set of calls used by a rendering pipeline
	34	* based on an AATileGenerator to communicate the alpha tile sequence
	35	* to the output (compositing) stages of the pipeline.
	36	*/
	37	public interface CompositePipe {
	38	public Object startSequence(SunGraphics2D sg, Shape s, Rectangle dev,
	39	int[] abox);
	40
	41	public boolean needTile(Object context, int x, int y, int w, int h);
	42
	43	public void renderPathTile(Object context,
	44	byte[] atile, int offset, int tilesize,
	45	int x, int y, int w, int h);
	46
	47	public void skipTile(Object context, int x, int y);
	48
	49	public void endSequence(Object context);
	50	}

java/pkg/sun/java2d/pipe/DrawImage.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/DrawImage.java+1110−0

@@ -0,0 +1,1110 @@
	1	/*
	2	* Copyright (c) 2001, 2008, 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.java2d.pipe;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.Color;
	30	import java.awt.Graphics2D;
	31	import java.awt.Image;
	32	import java.awt.Rectangle;
	33	import java.awt.Transparency;
	34	import java.awt.geom.AffineTransform;
	35	import java.awt.geom.NoninvertibleTransformException;
	36	import java.awt.image.AffineTransformOp;
	37	import java.awt.image.BufferedImage;
	38	import java.awt.image.BufferedImageOp;
	39	import java.awt.image.ColorModel;
	40	import java.awt.image.DataBuffer;
	41	import java.awt.image.DirectColorModel;
	42	import java.awt.image.ImageObserver;
	43	import java.awt.image.IndexColorModel;
	44	import java.awt.image.Raster;
	45	import java.awt.image.VolatileImage;
	46	import java.awt.image.WritableRaster;
	47	import java.awt.image.ImagingOpException;
	48	import sun.awt.SunHints;
	49	import sun.awt.image.ImageRepresentation;
	50	import sun.awt.image.ToolkitImage;
	51	import sun.java2d.InvalidPipeException;
	52	import sun.java2d.SunGraphics2D;
	53	import sun.java2d.SurfaceData;
	54	import sun.java2d.loops.Blit;
	55	import sun.java2d.loops.BlitBg;
	56	import sun.java2d.loops.TransformHelper;
	57	import sun.java2d.loops.MaskBlit;
	58	import sun.java2d.loops.CompositeType;
	59	import sun.java2d.loops.ScaledBlit;
	60	import sun.java2d.loops.SurfaceType;
	61
	62	public class DrawImage implements DrawImagePipe
	63	{
	64	public boolean copyImage(SunGraphics2D sg, Image img,
	65	int x, int y,
	66	Color bgColor)
	67	{
	68	int imgw = img.getWidth(null);
	69	int imgh = img.getHeight(null);
	70	if (isSimpleTranslate(sg)) {
	71	return renderImageCopy(sg, img, bgColor,
	72	x + sg.transX, y + sg.transY,
	73	0, 0, imgw, imgh);
	74	}
	75	AffineTransform atfm = sg.transform;
	76	if ((x \| y) != 0) {
	77	atfm = new AffineTransform(atfm);
	78	atfm.translate(x, y);
	79	}
	80	transformImage(sg, img, atfm, sg.interpolationType,
	81	0, 0, imgw, imgh, bgColor);
	82	return true;
	83	}
	84
	85	public boolean copyImage(SunGraphics2D sg, Image img,
	86	int dx, int dy, int sx, int sy, int w, int h,
	87	Color bgColor)
	88	{
	89	if (isSimpleTranslate(sg)) {
	90	return renderImageCopy(sg, img, bgColor,
	91	dx + sg.transX, dy + sg.transY,
	92	sx, sy, w, h);
	93	}
	94	scaleImage(sg, img, dx, dy, (dx + w), (dy + h),
	95	sx, sy, (sx + w), (sy + h), bgColor);
	96	return true;
	97	}
	98
	99	public boolean scaleImage(SunGraphics2D sg, Image img, int x, int y,
	100	int width, int height,
	101	Color bgColor)
	102	{
	103	int imgw = img.getWidth(null);
	104	int imgh = img.getHeight(null);
	105	// Only accelerate scale if:
	106	// - w/h positive values
	107	// - sg transform integer translate/identity only
	108	// - no bgColor in operation
	109	if ((width > 0) && (height > 0) && isSimpleTranslate(sg)) {
	110	double dx1 = x + sg.transX;
	111	double dy1 = y + sg.transY;
	112	double dx2 = dx1 + width;
	113	double dy2 = dy1 + height;
	114	if (renderImageScale(sg, img, bgColor, sg.interpolationType,
	115	0, 0, imgw, imgh,
	116	dx1, dy1, dx2, dy2))
	117	{
	118	return true;
	119	}
	120	}
	121
	122	AffineTransform atfm = sg.transform;
	123	if ((x \| y) != 0 \|\| width != imgw \|\| height != imgh) {
	124	atfm = new AffineTransform(atfm);
	125	atfm.translate(x, y);
	126	atfm.scale(((double)width)/imgw, ((double)height)/imgh);
	127	}
	128	transformImage(sg, img, atfm, sg.interpolationType,
	129	0, 0, imgw, imgh, bgColor);
	130	return true;
	131	}
	132
	133	/*
	134	* This method is only called in those circumstances where the
	135	* operation has a non-null secondary transform specfied. Its
	136	* role is to check for various optimizations based on the types
	137	* of both the secondary and SG2D transforms and to do some
	138	* quick calculations to avoid having to combine the transforms
	139	* and/or to call a more generalized method.
	140	*/
	141	protected void transformImage(SunGraphics2D sg, Image img, int x, int y,
	142	AffineTransform extraAT, int interpType)
	143	{
	144	int txtype = extraAT.getType();
	145	int imgw = img.getWidth(null);
	146	int imgh = img.getHeight(null);
	147	boolean checkfinalxform;
	148
	149	if (sg.transformState <= sg.TRANSFORM_ANY_TRANSLATE &&
	150	(txtype == AffineTransform.TYPE_IDENTITY \|\|
	151	txtype == AffineTransform.TYPE_TRANSLATION))
	152	{
	153	// First optimization - both are some kind of translate
	154
	155	// Combine the translations and check if interpolation is necessary.
	156	double tx = extraAT.getTranslateX();
	157	double ty = extraAT.getTranslateY();
	158	tx += sg.transform.getTranslateX();
	159	ty += sg.transform.getTranslateY();
	160	int itx = (int) Math.floor(tx + 0.5);
	161	int ity = (int) Math.floor(ty + 0.5);
	162	if (interpType == AffineTransformOp.TYPE_NEAREST_NEIGHBOR \|\|
	163	(closeToInteger(itx, tx) && closeToInteger(ity, ty)))
	164	{
	165	renderImageCopy(sg, img, null, x+itx, y+ity, 0, 0, imgw, imgh);
	166	return;
	167	}
	168	checkfinalxform = false;
	169	} else if (sg.transformState <= sg.TRANSFORM_TRANSLATESCALE &&
	170	((txtype & (AffineTransform.TYPE_FLIP \|
	171	AffineTransform.TYPE_MASK_ROTATION \|
	172	AffineTransform.TYPE_GENERAL_TRANSFORM)) == 0))
	173	{
	174	// Second optimization - both are some kind of translate or scale
	175
	176	// Combine the scales and check if interpolation is necessary.
	177
	178	// Transform source bounds by extraAT,
	179	// then translate the bounds again by x, y
	180	// then transform the bounds again by sg.transform
	181	double coords[] = new double[] {
	182	0, 0, imgw, imgh,
	183	};
	184	extraAT.transform(coords, 0, coords, 0, 2);
	185	coords[0] += x;
	186	coords[1] += y;
	187	coords[2] += x;
	188	coords[3] += y;
	189	sg.transform.transform(coords, 0, coords, 0, 2);
	190
	191	if (tryCopyOrScale(sg, img, 0, 0, imgw, imgh,
	192	null, interpType, coords))
	193	{
	194	return;
	195	}
	196	checkfinalxform = false;
	197	} else {
	198	checkfinalxform = true;
	199	}
	200
	201	// Begin Transform
	202	AffineTransform tx = new AffineTransform(sg.transform);
	203	tx.translate(x, y);
	204	tx.concatenate(extraAT);
	205
	206	// Do not try any more optimizations if either of the cases
	207	// above was tried as we have already verified that the
	208	// resulting transform will not simplify.
	209	if (checkfinalxform) {
	210	// In this case neither of the above simple transform
	211	// pairs was found so we will do some final tests on
	212	// the final rendering transform which may be the
	213	// simple product of two complex transforms.
	214	transformImage(sg, img, tx, interpType, 0, 0, imgw, imgh, null);
	215	} else {
	216	renderImageXform(sg, img, tx, interpType, 0, 0, imgw, imgh, null);
	217	}
	218	}
	219
	220	/*
	221	* This method is called with a final rendering transform that
	222	* has combined all of the information about the Graphics2D
	223	* transform attribute with the transformations specified by
	224	* the arguments to the drawImage call.
	225	* Its role is to see if the combined transform ends up being
	226	* acceleratable by either a renderImageCopy or renderImageScale
	227	* once all of the math is done.
	228	*
	229	* Note: The transform supplied here has an origin that is
	230	* already adjusted to point to the device location where
	231	* the (sx1, sy1) location of the source image should be placed.
	232	*/
	233	protected void transformImage(SunGraphics2D sg, Image img,
	234	AffineTransform tx, int interpType,
	235	int sx1, int sy1, int sx2, int sy2,
	236	Color bgColor)
	237	{
	238	// Transform 3 source corners by tx and analyze them
	239	// for simplified operations (Copy or Scale). Using
	240	// 3 points lets us analyze any kind of transform,
	241	// even transforms that involve very tiny amounts of
	242	// rotation or skew to see if they degenerate to a
	243	// simple scale or copy operation within the allowable
	244	// error bounds.
	245	// Note that we use (0,0,w,h) instead of (sx1,sy1,sx2,sy2)
	246	// because the transform is already translated such that
	247	// the origin is where sx1, sy1 should go.
	248	double coords[] = new double[6];
	249	/* index: 0 1 2 3 4 5 */
	250	/* coord: (0, 0), (w, h), (0, h) */
	251	coords[2] = sx2 - sx1;
	252	coords[3] = coords[5] = sy2 - sy1;
	253	tx.transform(coords, 0, coords, 0, 3);
	254	// First test if the X coords of the transformed UL
	255	// and LL points match and that the Y coords of the
	256	// transformed LR and LL points also match.
	257	// If they do then it is a "rectilinear" transform and
	258	// tryCopyOrScale will make sure it is upright and
	259	// integer-based.
	260	if (Math.abs(coords[0] - coords[4]) < MAX_TX_ERROR &&
	261	Math.abs(coords[3] - coords[5]) < MAX_TX_ERROR &&
	262	tryCopyOrScale(sg, img, sx1, sy1, sx2, sy2,
	263	bgColor, interpType, coords))
	264	{
	265	return;
	266	}
	267
	268	renderImageXform(sg, img, tx, interpType, sx1, sy1, sx2, sy2, bgColor);
	269	}
	270
	271	/*
	272	* Check the bounding coordinates of the transformed source
	273	* image to see if they fall on integer coordinates such
	274	* that they will cause no interpolation anomalies if we
	275	* use our simplified Blit or ScaledBlit operations instead
	276	* of a full transform operation.
	277	*/
	278	protected boolean tryCopyOrScale(SunGraphics2D sg,
	279	Image img,
	280	int sx1, int sy1,
	281	int sx2, int sy2,
	282	Color bgColor, int interpType,
	283	double coords[])
	284	{
	285	double dx = coords[0];
	286	double dy = coords[1];
	287	double dw = coords[2] - dx;
	288	double dh = coords[3] - dy;
	289	// First check if width and height are very close to img w&h.
	290	if (closeToInteger(sx2-sx1, dw) && closeToInteger(sy2-sy1, dh)) {
	291	// Round location to nearest pixel and then test
	292	// if it will cause interpolation anomalies.
	293	int idx = (int) Math.floor(dx + 0.5);
	294	int idy = (int) Math.floor(dy + 0.5);
	295	if (interpType == AffineTransformOp.TYPE_NEAREST_NEIGHBOR \|\|
	296	(closeToInteger(idx, dx) && closeToInteger(idy, dy)))
	297	{
	298	renderImageCopy(sg, img, bgColor,
	299	idx, idy,
	300	sx1, sy1, sx2-sx1, sy2-sy1);
	301	return true;
	302	}
	303	}
	304	// (For now) We can only use our ScaledBlits if the image
	305	// is upright (i.e. dw & dh both > 0)
	306	if (dw > 0 && dh > 0) {
	307	if (renderImageScale(sg, img, bgColor, interpType,
	308	sx1, sy1, sx2, sy2,
	309	coords[0], coords[1], coords[2], coords[3]))
	310	{
	311	return true;
	312	}
	313	}
	314	return false;
	315	}
	316
	317	/*
	318	* Return a BufferedImage of the requested type with the indicated
	319	* subimage of the original image located at 0,0 in the new image.
	320	* If a bgColor is supplied, composite the original image over that
	321	* color with a SrcOver operation, otherwise make a SrcNoEa copy.
	322	*/
	323	BufferedImage makeBufferedImage(Image img, Color bgColor, int type,
	324	int sx1, int sy1, int sx2, int sy2)
	325	{
	326	BufferedImage bimg = new BufferedImage(sx2-sx1, sy2-sy1, type);
	327	Graphics2D g2d = bimg.createGraphics();
	328	g2d.setComposite(AlphaComposite.Src);
	329	if (bgColor != null) {
	330	g2d.setColor(bgColor);
	331	g2d.fillRect(0, 0, sx2-sx1, sy2-sy1);
	332	g2d.setComposite(AlphaComposite.SrcOver);
	333	}
	334	g2d.drawImage(img, -sx1, -sy1, null);
	335	g2d.dispose();
	336	return bimg;
	337	}
	338
	339	protected void renderImageXform(SunGraphics2D sg, Image img,
	340	AffineTransform tx, int interpType,
	341	int sx1, int sy1, int sx2, int sy2,
	342	Color bgColor)
	343	{
	344	Region clip = sg.getCompClip();
	345	SurfaceData dstData = sg.surfaceData;
	346	SurfaceData srcData = dstData.getSourceSurfaceData(img,
	347	sg.TRANSFORM_GENERIC,
	348	sg.imageComp,
	349	bgColor);
	350
	351	if (srcData == null) {
	352	img = getBufferedImage(img);
	353	srcData = dstData.getSourceSurfaceData(img,
	354	sg.TRANSFORM_GENERIC,
	355	sg.imageComp,
	356	bgColor);
	357	if (srcData == null) {
	358	// REMIND: Is this correct? Can this happen?
	359	return;
	360	}
	361	}
	362
	363	if (isBgOperation(srcData, bgColor)) {
	364	// We cannot perform bg operations during transform so make
	365	// an opaque temp image with the appropriate background
	366	// and work from there.
	367	img = makeBufferedImage(img, bgColor, BufferedImage.TYPE_INT_RGB,
	368	sx1, sy1, sx2, sy2);
	369	// Temp image has appropriate subimage at 0,0 now.
	370	sx2 -= sx1;
	371	sy2 -= sy1;
	372	sx1 = sy1 = 0;
	373
	374	srcData = dstData.getSourceSurfaceData(img,
	375	sg.TRANSFORM_GENERIC,
	376	sg.imageComp,
	377	bgColor);
	378	}
	379
	380	SurfaceType srcType = srcData.getSurfaceType();
	381	TransformHelper helper = TransformHelper.getFromCache(srcType);
	382
	383	if (helper == null) {
	384	/* We have no helper for this source image type.
	385	* But we know that we do have helpers for both RGB and ARGB,
	386	* so convert to one of those types depending on transparency.
	387	* ARGB_PRE might be a better choice if the source image has
	388	* alpha, but it may cause some recursion here since we only
	389	* tend to have converters that convert to ARGB.
	390	*/
	391	int type = ((srcData.getTransparency() == Transparency.OPAQUE)
	392	? BufferedImage.TYPE_INT_RGB
	393	: BufferedImage.TYPE_INT_ARGB);
	394	img = makeBufferedImage(img, null, type, sx1, sy1, sx2, sy2);
	395	// Temp image has appropriate subimage at 0,0 now.
	396	sx2 -= sx1;
	397	sy2 -= sy1;
	398	sx1 = sy1 = 0;
	399
	400	srcData = dstData.getSourceSurfaceData(img,
	401	sg.TRANSFORM_GENERIC,
	402	sg.imageComp,
	403	null);
	404	srcType = srcData.getSurfaceType();
	405	helper = TransformHelper.getFromCache(srcType);
	406	// assert(helper != null);
	407	}
	408
	409	AffineTransform itx;
	410	try {
	411	itx = tx.createInverse();
	412	} catch (NoninvertibleTransformException e) {
	413	// Non-invertible transform means no output
	414	return;
	415	}
	416
	417	/*
	418	* Find the maximum bounds on the destination that will be
	419	* affected by the transformed source. First, transform all
	420	* four corners of the source and then min and max the resulting
	421	* destination coordinates of the transformed corners.
	422	* Note that tx already has the offset to sx1,sy1 accounted
	423	* for so we use the box (0, 0, sx2-sx1, sy2-sy1) as the
	424	* source coordinates.
	425	*/
	426	double coords[] = new double[8];
	427	/* corner: UL UR LL LR */
	428	/* index: 0 1 2 3 4 5 6 7 */
	429	/* coord: (0, 0), (w, 0), (0, h), (w, h) */
	430	coords[2] = coords[6] = sx2 - sx1;
	431	coords[5] = coords[7] = sy2 - sy1;
	432	tx.transform(coords, 0, coords, 0, 4);
	433	double ddx1, ddy1, ddx2, ddy2;
	434	ddx1 = ddx2 = coords[0];
	435	ddy1 = ddy2 = coords[1];
	436	for (int i = 2; i < coords.length; i += 2) {
	437	double d = coords[i];
	438	if (ddx1 > d) ddx1 = d;
	439	else if (ddx2 < d) ddx2 = d;
	440	d = coords[i+1];
	441	if (ddy1 > d) ddy1 = d;
	442	else if (ddy2 < d) ddy2 = d;
	443	}
	444	int dx1 = (int) Math.floor(ddx1);
	445	int dy1 = (int) Math.floor(ddy1);
	446	int dx2 = (int) Math.ceil(ddx2);
	447	int dy2 = (int) Math.ceil(ddy2);
	448
	449	SurfaceType dstType = dstData.getSurfaceType();
	450	MaskBlit maskblit;
	451	Blit blit;
	452	if (sg.compositeState <= sg.COMP_ALPHA) {
	453	/* NOTE: We either have, or we can make,
	454	* a MaskBlit for any alpha composite type
	455	*/
	456	maskblit = MaskBlit.getFromCache(SurfaceType.IntArgbPre,
	457	sg.imageComp,
	458	dstType);
	459
	460	/* NOTE: We can only use the native TransformHelper
	461	* func to go directly to the dest if both the helper
	462	* and the MaskBlit are native.
	463	* All helpers are native at this point, but some MaskBlit
	464	* objects are implemented in Java, so we need to check.
	465	*/
	466	if (maskblit.getNativePrim() != 0) {
	467	// We can render directly.
	468	helper.Transform(maskblit, srcData, dstData,
	469	sg.composite, clip,
	470	itx, interpType,
	471	sx1, sy1, sx2, sy2,
	472	dx1, dy1, dx2, dy2,
	473	null, 0, 0);
	474	return;
	475	}
	476	blit = null;
	477	} else {
	478	/* NOTE: We either have, or we can make,
	479	* a Blit for any composite type, even Custom
	480	*/
	481	maskblit = null;
	482	blit = Blit.getFromCache(SurfaceType.IntArgbPre,
	483	sg.imageComp,
	484	dstType);
	485	}
	486
	487	// We need to transform to a temp image and then copy
	488	// just the pieces that are valid data to the dest.
	489	BufferedImage tmpimg = new BufferedImage(dx2-dx1, dy2-dy1,
	490	BufferedImage.TYPE_INT_ARGB);
	491	SurfaceData tmpData = SurfaceData.getPrimarySurfaceData(tmpimg);
	492	SurfaceType tmpType = tmpData.getSurfaceType();
	493	MaskBlit tmpmaskblit =
	494	MaskBlit.getFromCache(SurfaceType.IntArgbPre,
	495	CompositeType.SrcNoEa,
	496	tmpType);
	497	/*
	498	* The helper function fills a temporary edges buffer
	499	* for us with the bounding coordinates of each scanline
	500	* in the following format:
	501	*
	502	* edges[0, 1] = [top y, bottom y)
	503	* edges[2, 3] = [left x, right x) of top row
	504	* ...
	505	* edges[h2, h2+1] = [left x, right x) of bottom row
	506	*
	507	* all coordinates in the edges array will be relative to dx1, dy1
	508	*
	509	* edges thus has to be h*2+2 in length
	510	*/
	511	int edges[] = new int[(dy2-dy1)*2+2];
	512	// It is important that edges[0]=edges[1]=0 when we call
	513	// Transform in case it must return early and we would
	514	// not want to render anything on an error condition.
	515	helper.Transform(tmpmaskblit, srcData, tmpData,
	516	AlphaComposite.Src, null,
	517	itx, interpType,
	518	sx1, sy1, sx2, sy2,
	519	0, 0, dx2-dx1, dy2-dy1,
	520	edges, dx1, dy1);
	521
	522	/*
	523	* Now copy the results, scanline by scanline, into the dest.
	524	* The edges array helps us minimize the work.
	525	*/
	526	int index = 2;
	527	for (int y = edges[0]; y < edges[1]; y++) {
	528	int relx1 = edges[index++];
	529	int relx2 = edges[index++];
	530	if (relx1 >= relx2) {
	531	continue;
	532	}
	533	if (maskblit != null) {
	534	maskblit.MaskBlit(tmpData, dstData,
	535	sg.composite, clip,
	536	relx1, y,
	537	dx1+relx1, dy1+y,
	538	relx2 - relx1, 1,
	539	null, 0, 0);
	540	} else {
	541	blit.Blit(tmpData, dstData,
	542	sg.composite, clip,
	543	relx1, y,
	544	dx1+relx1, dy1+y,
	545	relx2 - relx1, 1);
	546	}
	547	}
	548	}
	549
	550	// Render an image using only integer translation
	551	// (no scale or transform or sub-pixel interpolated translations).
	552	protected boolean renderImageCopy(SunGraphics2D sg, Image img,
	553	Color bgColor,
	554	int dx, int dy,
	555	int sx, int sy,
	556	int w, int h)
	557	{
	558	Region clip = sg.getCompClip();
	559	SurfaceData dstData = sg.surfaceData;
	560
	561	int attempts = 0;
	562	// Loop up to twice through; this gives us a chance to
	563	// revalidate the surfaceData objects in case of an exception
	564	// and try it once more
	565	while (true) {
	566	SurfaceData srcData =
	567	dstData.getSourceSurfaceData(img,
	568	sg.TRANSFORM_ISIDENT,
	569	sg.imageComp,
	570	bgColor);
	571	if (srcData == null) {
	572	return false;
	573	}
	574
	575	try {
	576	SurfaceType srcType = srcData.getSurfaceType();
	577	SurfaceType dstType = dstData.getSurfaceType();
	578	blitSurfaceData(sg, clip,
	579	srcData, dstData, srcType, dstType,
	580	sx, sy, dx, dy, w, h, bgColor);
	581	return true;
	582	} catch (NullPointerException e) {
	583	if (!(SurfaceData.isNull(dstData) \|\|
	584	SurfaceData.isNull(srcData)))
	585	{
	586	// Something else caused the exception, throw it...
	587	throw e;
	588	}
	589	return false;
	590	// NOP if we have been disposed
	591	} catch (InvalidPipeException e) {
	592	// Always catch the exception; try this a couple of times
	593	// and fail silently if the system is not yet ready to
	594	// revalidate the source or dest surfaceData objects.
	595	++attempts;
	596	clip = sg.getCompClip(); // ensures sg.surfaceData is valid
	597	dstData = sg.surfaceData;
	598	if (SurfaceData.isNull(dstData) \|\|
	599	SurfaceData.isNull(srcData) \|\| (attempts > 1))
	600	{
	601	return false;
	602	}
	603	}
	604	}
	605	}
	606
	607	// Render an image using only integer scaling (no transform).
	608	protected boolean renderImageScale(SunGraphics2D sg, Image img,
	609	Color bgColor, int interpType,
	610	int sx1, int sy1,
	611	int sx2, int sy2,
	612	double dx1, double dy1,
	613	double dx2, double dy2)
	614	{
	615	// Currently only NEAREST_NEIGHBOR interpolation is implemented
	616	// for ScaledBlit operations.
	617	if (interpType != AffineTransformOp.TYPE_NEAREST_NEIGHBOR) {
	618	return false;
	619	}
	620
	621	Region clip = sg.getCompClip();
	622	SurfaceData dstData = sg.surfaceData;
	623
	624	int attempts = 0;
	625	// Loop up to twice through; this gives us a chance to
	626	// revalidate the surfaceData objects in case of an exception
	627	// and try it once more
	628	while (true) {
	629	SurfaceData srcData =
	630	dstData.getSourceSurfaceData(img,
	631	sg.TRANSFORM_TRANSLATESCALE,
	632	sg.imageComp,
	633	bgColor);
	634
	635	if (srcData == null \|\| isBgOperation(srcData, bgColor)) {
	636	return false;
	637	}
	638
	639	try {
	640	SurfaceType srcType = srcData.getSurfaceType();
	641	SurfaceType dstType = dstData.getSurfaceType();
	642	return scaleSurfaceData(sg, clip,
	643	srcData, dstData, srcType, dstType,
	644	sx1, sy1, sx2, sy2,
	645	dx1, dy1, dx2, dy2);
	646	} catch (NullPointerException e) {
	647	if (!SurfaceData.isNull(dstData)) {
	648	// Something else caused the exception, throw it...
	649	throw e;
	650	}
	651	return false;
	652	// NOP if we have been disposed
	653	} catch (InvalidPipeException e) {
	654	// Always catch the exception; try this a couple of times
	655	// and fail silently if the system is not yet ready to
	656	// revalidate the source or dest surfaceData objects.
	657	++attempts;
	658	clip = sg.getCompClip(); // ensures sg.surfaceData is valid
	659	dstData = sg.surfaceData;
	660	if (SurfaceData.isNull(dstData) \|\|
	661	SurfaceData.isNull(srcData) \|\| (attempts > 1))
	662	{
	663	return false;
	664	}
	665	}
	666	}
	667	}
	668
	669	public boolean scaleImage(SunGraphics2D sg, Image img,
	670	int dx1, int dy1, int dx2, int dy2,
	671	int sx1, int sy1, int sx2, int sy2,
	672	Color bgColor)
	673	{
	674	int srcW, srcH, dstW, dstH;
	675	int srcX, srcY, dstX, dstY;
	676	boolean srcWidthFlip = false;
	677	boolean srcHeightFlip = false;
	678	boolean dstWidthFlip = false;
	679	boolean dstHeightFlip = false;
	680
	681	if (sx2 > sx1) {
	682	srcW = sx2 - sx1;
	683	srcX = sx1;
	684	} else {
	685	srcWidthFlip = true;
	686	srcW = sx1 - sx2;
	687	srcX = sx2;
	688	}
	689	if (sy2 > sy1) {
	690	srcH = sy2-sy1;
	691	srcY = sy1;
	692	} else {
	693	srcHeightFlip = true;
	694	srcH = sy1-sy2;
	695	srcY = sy2;
	696	}
	697	if (dx2 > dx1) {
	698	dstW = dx2 - dx1;
	699	dstX = dx1;
	700	} else {
	701	dstW = dx1 - dx2;
	702	dstWidthFlip = true;
	703	dstX = dx2;
	704	}
	705	if (dy2 > dy1) {
	706	dstH = dy2 - dy1;
	707	dstY = dy1;
	708	} else {
	709	dstH = dy1 - dy2;
	710	dstHeightFlip = true;
	711	dstY = dy2;
	712	}
	713	if (srcW <= 0 \|\| srcH <= 0) {
	714	return true;
	715	}
	716	// Only accelerate scale if it does not involve a flip or transform
	717	if ((srcWidthFlip == dstWidthFlip) &&
	718	(srcHeightFlip == dstHeightFlip) &&
	719	isSimpleTranslate(sg))
	720	{
	721	double ddx1 = dstX + sg.transX;
	722	double ddy1 = dstY + sg.transY;
	723	double ddx2 = ddx1 + dstW;
	724	double ddy2 = ddy1 + dstH;
	725	if (renderImageScale(sg, img, bgColor, sg.interpolationType,
	726	srcX, srcY, srcX+srcW, srcY+srcH,
	727	ddx1, ddy1, ddx2, ddy2))
	728	{
	729	return true;
	730	}
	731	}
	732
	733	AffineTransform atfm = new AffineTransform(sg.transform);
	734	atfm.translate(dx1, dy1);
	735	double m00 = (double)(dx2-dx1)/(sx2-sx1);
	736	double m11 = (double)(dy2-dy1)/(sy2-sy1);
	737	atfm.scale(m00, m11);
	738	atfm.translate(srcX-sx1, srcY-sy1);
	739
	740	int imgW = img.getWidth(null);
	741	int imgH = img.getHeight(null);
	742	srcW += srcX;
	743	srcH += srcY;
	744	// Make sure we are not out of bounds
	745	if (srcW > imgW) {
	746	srcW = imgW;
	747	}
	748	if (srcH > imgH) {
	749	srcH = imgH;
	750	}
	751	if (srcX < 0) {
	752	atfm.translate(-srcX, 0);
	753	srcX = 0;
	754	}
	755	if (srcY < 0) {
	756	atfm.translate(0, -srcY);
	757	srcY = 0;
	758	}
	759	if (srcX >= srcW \|\| srcY >= srcH) {
	760	return true;
	761	}
	762	// Note: src[WH] are currently the right and bottom coordinates.
	763	// The following two lines would adjust src[WH] back to being
	764	// dimensions.
	765	// srcW -= srcX;
	766	// srcH -= srcY;
	767	// Since transformImage needs right and bottom coords we will
	768	// omit this adjustment.
	769
	770	transformImage(sg, img, atfm, sg.interpolationType,
	771	srcX, srcY, srcW, srcH, bgColor);
	772	return true;
	773	}
	774
	775	/**
	776	** Utilities
	777	** The following methods are used by the public methods above
	778	** for performing various operations
	779	**/
	780
	781	/*
	782	* This constant represents a tradeoff between the
	783	* need to make sure that image transformations are
	784	* "very close" to integer device coordinates before
	785	* we decide to use an integer scale or copy operation
	786	* as a substitute and the fact that roundoff errors
	787	* in AffineTransforms are frequently introduced by
	788	* performing multiple sequential operations on them.
	789	*
	790	* The evaluation of bug 4990624 details the potential
	791	* for this error cutoff to result in display anomalies
	792	* in different types of image operations and how this
	793	* value represents a good compromise here.
	794	*/
	795	private static final double MAX_TX_ERROR = .0001;
	796
	797	public static boolean closeToInteger(int i, double d) {
	798	return (Math.abs(d-i) < MAX_TX_ERROR);
	799	}
	800
	801	public static boolean isSimpleTranslate(SunGraphics2D sg) {
	802	int ts = sg.transformState;
	803	if (ts <= sg.TRANSFORM_INT_TRANSLATE) {
	804	// Integer translates are always "simple"
	805	return true;
	806	}
	807	if (ts >= sg.TRANSFORM_TRANSLATESCALE) {
	808	// Scales and beyond are always "not simple"
	809	return false;
	810	}
	811	// non-integer translates are only simple when not interpolating
	812	if (sg.interpolationType == AffineTransformOp.TYPE_NEAREST_NEIGHBOR) {
	813	return true;
	814	}
	815	return false;
	816	}
	817
	818	protected static boolean isBgOperation(SurfaceData srcData, Color bgColor) {
	819	// If we cannot get the srcData, then cannot assume anything about
	820	// the image
	821	return ((srcData == null) \|\|
	822	((bgColor != null) &&
	823	(srcData.getTransparency() != Transparency.OPAQUE)));
	824	}
	825
	826	protected BufferedImage getBufferedImage(Image img) {
	827	if (img instanceof BufferedImage) {
	828	return (BufferedImage)img;
	829	}
	830	// Must be VolatileImage; get BufferedImage representation
	831	return ((VolatileImage)img).getSnapshot();
	832	}
	833
	834	/*
	835	* Return the color model to be used with this BufferedImage and
	836	* transform.
	837	*/
	838	private ColorModel getTransformColorModel(SunGraphics2D sg,
	839	BufferedImage bImg,
	840	AffineTransform tx) {
	841	ColorModel cm = bImg.getColorModel();
	842	ColorModel dstCM = cm;
	843
	844	if (tx.isIdentity()) {
	845	return dstCM;
	846	}
	847	int type = tx.getType();
	848	boolean needTrans =
	849	((type&(tx.TYPE_MASK_ROTATION\|tx.TYPE_GENERAL_TRANSFORM)) != 0);
	850	if (! needTrans && type != tx.TYPE_TRANSLATION && type != tx.TYPE_IDENTITY)
	851	{
	852	double[] mtx = new double[4];
	853	tx.getMatrix(mtx);
	854	// Check out the matrix. A non-integral scale will force ARGB
	855	// since the edge conditions cannot be guaranteed.
	856	needTrans = (mtx[0] != (int)mtx[0] \|\| mtx[3] != (int)mtx[3]);
	857	}
	858
	859	if (sg.renderHint != SunHints.INTVAL_RENDER_QUALITY) {
	860	if (cm instanceof IndexColorModel) {
	861	Raster raster = bImg.getRaster();
	862	IndexColorModel icm = (IndexColorModel) cm;
	863	// Just need to make sure that we have a transparent pixel
	864	if (needTrans && cm.getTransparency() == cm.OPAQUE) {
	865	// Fix 4221407
	866	if (raster instanceof sun.awt.image.BytePackedRaster) {
	867	dstCM = ColorModel.getRGBdefault();
	868	}
	869	else {
	870	double[] matrix = new double[6];
	871	tx.getMatrix(matrix);
	872	if (matrix[1] == 0. && matrix[2] ==0.
	873	&& matrix[4] == 0. && matrix[5] == 0.) {
	874	// Only scaling so do not need to create
	875	}
	876	else {
	877	int mapSize = icm.getMapSize();
	878	if (mapSize < 256) {
	879	int[] cmap = new int[mapSize+1];
	880	icm.getRGBs(cmap);
	881	cmap[mapSize] = 0x0000;
	882	dstCM = new
	883	IndexColorModel(icm.getPixelSize(),
	884	mapSize+1,
	885	cmap, 0, true, mapSize,
	886	DataBuffer.TYPE_BYTE);
	887	}
	888	else {
	889	dstCM = ColorModel.getRGBdefault();
	890	}
	891	} /* if (matrix[0] < 1.f ...) */
	892	} /* raster instanceof sun.awt.image.BytePackedRaster */
	893	} /* if (cm.getTransparency() == cm.OPAQUE) */
	894	} /* if (cm instanceof IndexColorModel) */
	895	else if (needTrans && cm.getTransparency() == cm.OPAQUE) {
	896	// Need a bitmask transparency
	897	// REMIND: for now, use full transparency since no loops
	898	// for bitmask
	899	dstCM = ColorModel.getRGBdefault();
	900	}
	901	} /* if (sg.renderHint == RENDER_QUALITY) */
	902	else {
	903
	904	if (cm instanceof IndexColorModel \|\|
	905	(needTrans && cm.getTransparency() == cm.OPAQUE))
	906	{
	907	// Need a bitmask transparency
	908	// REMIND: for now, use full transparency since no loops
	909	// for bitmask
	910	dstCM = ColorModel.getRGBdefault();
	911	}
	912	}
	913
	914	return dstCM;
	915	}
	916
	917	protected void blitSurfaceData(SunGraphics2D sg,
	918	Region clipRegion,
	919	SurfaceData srcData,
	920	SurfaceData dstData,
	921	SurfaceType srcType,
	922	SurfaceType dstType,
	923	int sx, int sy, int dx, int dy,
	924	int w, int h,
	925	Color bgColor)
	926	{
	927	if (w <= 0 \|\| h <= 0) {
	928	/*
	929	* Fix for bugid 4783274 - BlitBg throws an exception for
	930	* a particular set of anomalous parameters.
	931	* REMIND: The native loops do proper clipping and would
	932	* detect this situation themselves, but the Java loops
	933	* all seem to trust their parameters a little too well
	934	* to the point where they will try to process a negative
	935	* area of pixels and throw exceptions. The real fix is
	936	* to modify the Java loops to do proper clipping so that
	937	* they can deal with negative dimensions as well as
	938	* improperly large dimensions, but that fix is too risky
	939	* to integrate for Mantis at this point. In the meantime
	940	* eliminating the negative or zero dimensions here is
	941	* "correct" and saves them from some nasty exceptional
	942	* conditions, one of which is the test case of 4783274.
	943	*/
	944	return;
	945	}
	946	CompositeType comp = sg.imageComp;
	947	if (CompositeType.SrcOverNoEa.equals(comp) &&
	948	(srcData.getTransparency() == Transparency.OPAQUE \|\|
	949	(bgColor != null &&
	950	bgColor.getTransparency() == Transparency.OPAQUE)))
	951	{
	952	comp = CompositeType.SrcNoEa;
	953	}
	954	if (!isBgOperation(srcData, bgColor)) {
	955	Blit blit = Blit.getFromCache(srcType, comp, dstType);
	956	blit.Blit(srcData, dstData, sg.composite, clipRegion,
	957	sx, sy, dx, dy, w, h);
	958	} else {
	959	BlitBg blit = BlitBg.getFromCache(srcType, comp, dstType);
	960	blit.BlitBg(srcData, dstData, sg.composite, clipRegion,
	961	bgColor.getRGB(), sx, sy, dx, dy, w, h);
	962	}
	963	}
	964
	965	protected boolean scaleSurfaceData(SunGraphics2D sg,
	966	Region clipRegion,
	967	SurfaceData srcData,
	968	SurfaceData dstData,
	969	SurfaceType srcType,
	970	SurfaceType dstType,
	971	int sx1, int sy1,
	972	int sx2, int sy2,
	973	double dx1, double dy1,
	974	double dx2, double dy2)
	975	{
	976	CompositeType comp = sg.imageComp;
	977	if (CompositeType.SrcOverNoEa.equals(comp) &&
	978	(srcData.getTransparency() == Transparency.OPAQUE))
	979	{
	980	comp = CompositeType.SrcNoEa;
	981	}
	982
	983	ScaledBlit blit = ScaledBlit.getFromCache(srcType, comp, dstType);
	984	if (blit != null) {
	985	blit.Scale(srcData, dstData, sg.composite, clipRegion,
	986	sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2);
	987	return true;
	988	}
	989	return false;
	990	}
	991
	992	protected static boolean imageReady(ToolkitImage sunimg,
	993	ImageObserver observer)
	994	{
	995	if (sunimg.hasError()) {
	996	if (observer != null) {
	997	observer.imageUpdate(sunimg,
	998	ImageObserver.ERROR\|ImageObserver.ABORT,
	999	-1, -1, -1, -1);
	1000	}
	1001	return false;
	1002	}
	1003	return true;
	1004	}
	1005
	1006	public boolean copyImage(SunGraphics2D sg, Image img,
	1007	int x, int y,
	1008	Color bgColor,
	1009	ImageObserver observer) {
	1010	if (!(img instanceof ToolkitImage)) {
	1011	return copyImage(sg, img, x, y, bgColor);
	1012	} else {
	1013	ToolkitImage sunimg = (ToolkitImage)img;
	1014	if (!imageReady(sunimg, observer)) {
	1015	return false;
	1016	}
	1017	ImageRepresentation ir = sunimg.getImageRep();
	1018	return ir.drawToBufImage(sg, sunimg, x, y, bgColor, observer);
	1019	}
	1020	}
	1021
	1022	public boolean copyImage(SunGraphics2D sg, Image img,
	1023	int dx, int dy, int sx, int sy, int w, int h,
	1024	Color bgColor,
	1025	ImageObserver observer) {
	1026	if (!(img instanceof ToolkitImage)) {
	1027	return copyImage(sg, img, dx, dy, sx, sy, w, h, bgColor);
	1028	} else {
	1029	ToolkitImage sunimg = (ToolkitImage)img;
	1030	if (!imageReady(sunimg, observer)) {
	1031	return false;
	1032	}
	1033	ImageRepresentation ir = sunimg.getImageRep();
	1034	return ir.drawToBufImage(sg, sunimg,
	1035	dx, dy, (dx + w), (dy + h),
	1036	sx, sy, (sx + w), (sy + h),
	1037	bgColor, observer);
	1038	}
	1039	}
	1040
	1041	public boolean scaleImage(SunGraphics2D sg, Image img,
	1042	int x, int y,
	1043	int width, int height,
	1044	Color bgColor,
	1045	ImageObserver observer) {
	1046	if (!(img instanceof ToolkitImage)) {
	1047	return scaleImage(sg, img, x, y, width, height, bgColor);
	1048	} else {
	1049	ToolkitImage sunimg = (ToolkitImage)img;
	1050	if (!imageReady(sunimg, observer)) {
	1051	return false;
	1052	}
	1053	ImageRepresentation ir = sunimg.getImageRep();
	1054	return ir.drawToBufImage(sg, sunimg, x, y, width, height, bgColor,
	1055	observer);
	1056	}
	1057	}
	1058
	1059	public boolean scaleImage(SunGraphics2D sg, Image img,
	1060	int dx1, int dy1, int dx2, int dy2,
	1061	int sx1, int sy1, int sx2, int sy2,
	1062	Color bgColor,
	1063	ImageObserver observer) {
	1064	if (!(img instanceof ToolkitImage)) {
	1065	return scaleImage(sg, img, dx1, dy1, dx2, dy2,
	1066	sx1, sy1, sx2, sy2, bgColor);
	1067	} else {
	1068	ToolkitImage sunimg = (ToolkitImage)img;
	1069	if (!imageReady(sunimg, observer)) {
	1070	return false;
	1071	}
	1072	ImageRepresentation ir = sunimg.getImageRep();
	1073	return ir.drawToBufImage(sg, sunimg, dx1, dy1, dx2, dy2,
	1074	sx1, sy1, sx2, sy2, bgColor, observer);
	1075	}
	1076	}
	1077
	1078	public boolean transformImage(SunGraphics2D sg, Image img,
	1079	AffineTransform atfm,
	1080	ImageObserver observer) {
	1081	if (!(img instanceof ToolkitImage)) {
	1082	transformImage(sg, img, 0, 0, atfm, sg.interpolationType);
	1083	return true;
	1084	} else {
	1085	ToolkitImage sunimg = (ToolkitImage)img;
	1086	if (!imageReady(sunimg, observer)) {
	1087	return false;
	1088	}
	1089	ImageRepresentation ir = sunimg.getImageRep();
	1090	return ir.drawToBufImage(sg, sunimg, atfm, observer);
	1091	}
	1092	}
	1093
	1094	public void transformImage(SunGraphics2D sg, BufferedImage img,
	1095	BufferedImageOp op, int x, int y)
	1096	{
	1097	if (op != null) {
	1098	if (op instanceof AffineTransformOp) {
	1099	AffineTransformOp atop = (AffineTransformOp) op;
	1100	transformImage(sg, img, x, y,
	1101	atop.getTransform(),
	1102	atop.getInterpolationType());
	1103	return;
	1104	} else {
	1105	img = op.filter(img, null);
	1106	}
	1107	}
	1108	copyImage(sg, img, x, y, null);
	1109	}
	1110	}

java/pkg/sun/java2d/pipe/DrawImagePipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/DrawImagePipe.java+86−0

@@ -0,0 +1,86 @@
	1	/*
	2	* Copyright (c) 2001, 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.java2d.pipe;
	27
	28	import java.awt.Color;
	29	import java.awt.Image;
	30	import java.awt.image.BufferedImage;
	31	import java.awt.image.BufferedImageOp;
	32	import java.awt.image.ImageObserver;
	33	import java.awt.geom.AffineTransform;
	34	import sun.java2d.SunGraphics2D;
	35
	36	/**
	37	* This interface defines the set of calls that pipeline objects
	38	* can use to pass on responsibility for performing various
	39	* image copy commands.
	40	* There are 3 types of image copies handled by this class:
	41	* - copyImage: These methods simply copy the pixels
	42	* from the src to dest, either from (0, 0) (implicit)
	43	* or from a given (sx, sy) location.
	44	* - scaleImage: These methods copy from src to dest while
	45	* scaling the source image. The src and dest rectangles
	46	* are used to specify the scale.
	47	* - copyImageBg: These methods behave the same as the
	48	* copyImage methods except they substitute the given
	49	* background color for any transparent pixels.
	50	* - scaleImageBg: These methods behave the same as the
	51	* scaleImage methods except they substitute the given
	52	* background color for any transparent pixels.
	53	* - transformImage....
	54	*/
	55	public interface DrawImagePipe {
	56
	57	public boolean copyImage(SunGraphics2D sg, Image img,
	58	int x, int y,
	59	Color bgColor,
	60	ImageObserver observer);
	61
	62	public boolean copyImage(SunGraphics2D sg, Image img,
	63	int dx, int dy, int sx, int sy, int w, int h,
	64	Color bgColor,
	65	ImageObserver observer);
	66
	67	public boolean scaleImage(SunGraphics2D sg, Image img, int x, int y,
	68	int width, int height,
	69	Color bgColor,
	70	ImageObserver observer);
	71
	72	public boolean scaleImage(SunGraphics2D sg, Image img,
	73	int dx1, int dy1, int dx2, int dy2,
	74	int sx1, int sy1, int sx2, int sy2,
	75	Color bgColor,
	76	ImageObserver observer);
	77
	78	public boolean transformImage(SunGraphics2D sg, Image img,
	79	AffineTransform atfm,
	80	ImageObserver observer);
	81
	82	public void transformImage(SunGraphics2D sg, BufferedImage img,
	83	BufferedImageOp op, int x, int y);
	84
	85
	86	}

java/pkg/sun/java2d/pipe/GeneralCompositePipe$TileContext.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/GeneralCompositePipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/GeneralCompositePipe.java+154−0

@@ -0,0 +1,154 @@
	1	/*
	2	* Copyright (c) 1997, 2002, 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.java2d.pipe;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.CompositeContext;
	30	import java.awt.PaintContext;
	31	import java.awt.Rectangle;
	32	import java.awt.Shape;
	33	import java.awt.RenderingHints;
	34	import java.awt.image.ColorModel;
	35	import java.awt.image.BufferedImage;
	36	import java.awt.image.Raster;
	37	import java.awt.image.WritableRaster;
	38	import sun.awt.image.BufImgSurfaceData;
	39	import sun.java2d.SunGraphics2D;
	40	import sun.java2d.SurfaceData;
	41	import sun.java2d.loops.Blit;
	42	import sun.java2d.loops.MaskBlit;
	43	import sun.java2d.loops.CompositeType;
	44
	45	public class GeneralCompositePipe implements CompositePipe {
	46	class TileContext {
	47	SunGraphics2D sunG2D;
	48	PaintContext paintCtxt;
	49	CompositeContext compCtxt;
	50	ColorModel compModel;
	51	Object pipeState;
	52
	53	public TileContext(SunGraphics2D sg, PaintContext pCtx,
	54	CompositeContext cCtx, ColorModel cModel) {
	55	sunG2D = sg;
	56	paintCtxt = pCtx;
	57	compCtxt = cCtx;
	58	compModel = cModel;
	59	}
	60	}
	61
	62	public Object startSequence(SunGraphics2D sg, Shape s, Rectangle devR,
	63	int[] abox) {
	64	RenderingHints hints = sg.getRenderingHints();
	65	ColorModel model = sg.getDeviceColorModel();
	66	PaintContext paintContext =
	67	sg.paint.createContext(model, devR, s.getBounds2D(),
	68	sg.cloneTransform(),
	69	hints);
	70	CompositeContext compositeContext =
	71	sg.composite.createContext(paintContext.getColorModel(), model,
	72	hints);
	73	return new TileContext(sg, paintContext, compositeContext, model);
	74	}
	75
	76	public boolean needTile(Object ctx, int x, int y, int w, int h) {
	77	return true;
	78	}
	79
	80	/**
	81	* GeneralCompositePipe.renderPathTile works with custom composite operator
	82	* provided by an application
	83	*/
	84	public void renderPathTile(Object ctx,
	85	byte[] atile, int offset, int tilesize,
	86	int x, int y, int w, int h) {
	87	TileContext context = (TileContext) ctx;
	88	PaintContext paintCtxt = context.paintCtxt;
	89	CompositeContext compCtxt = context.compCtxt;
	90	SunGraphics2D sg = context.sunG2D;
	91
	92	Raster srcRaster = paintCtxt.getRaster(x, y, w, h);
	93	ColorModel paintModel = paintCtxt.getColorModel();
	94
	95	Raster dstRaster;
	96	Raster dstIn;
	97	WritableRaster dstOut;
	98
	99	SurfaceData sd = sg.getSurfaceData();
	100	dstRaster = sd.getRaster(x, y, w, h);
	101	if (dstRaster instanceof WritableRaster && atile == null) {
	102	dstOut = (WritableRaster) dstRaster;
	103	dstOut = dstOut.createWritableChild(x, y, w, h, 0, 0, null);
	104	dstIn = dstOut;
	105	} else {
	106	dstIn = dstRaster.createChild(x, y, w, h, 0, 0, null);
	107	dstOut = dstIn.createCompatibleWritableRaster();
	108	}
	109
	110	compCtxt.compose(srcRaster, dstIn, dstOut);
	111
	112	if (dstRaster != dstOut && dstOut.getParent() != dstRaster) {
	113	if (dstRaster instanceof WritableRaster && atile == null) {
	114	((WritableRaster) dstRaster).setDataElements(x, y, dstOut);
	115	} else {
	116	ColorModel cm = sg.getDeviceColorModel();
	117	BufferedImage resImg =
	118	new BufferedImage(cm, dstOut,
	119	cm.isAlphaPremultiplied(),
	120	null);
	121	SurfaceData resData = BufImgSurfaceData.createData(resImg);
	122	if (atile == null) {
	123	Blit blit = Blit.getFromCache(resData.getSurfaceType(),
	124	CompositeType.SrcNoEa,
	125	sd.getSurfaceType());
	126	blit.Blit(resData, sd, AlphaComposite.Src, null,
	127	0, 0, x, y, w, h);
	128	} else {
	129	MaskBlit blit = MaskBlit.getFromCache(resData.getSurfaceType(),
	130	CompositeType.SrcNoEa,
	131	sd.getSurfaceType());
	132	blit.MaskBlit(resData, sd, AlphaComposite.Src, null,
	133	0, 0, x, y, w, h,
	134	atile, offset, tilesize);
	135	}
	136	}
	137	}
	138	}
	139
	140	public void skipTile(Object ctx, int x, int y) {
	141	return;
	142	}
	143
	144	public void endSequence(Object ctx) {
	145	TileContext context = (TileContext) ctx;
	146	if (context.paintCtxt != null) {
	147	context.paintCtxt.dispose();
	148	}
	149	if (context.compCtxt != null) {
	150	context.compCtxt.dispose();
	151	}
	152	}
	153
	154	}

java/pkg/sun/java2d/pipe/GlyphListLoopPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/GlyphListLoopPipe.java+60−0

@@ -0,0 +1,60 @@
	1	/*
	2	* Copyright (c) 2005, 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.java2d.pipe;
	27
	28	import java.awt.font.GlyphVector;
	29	import sun.awt.SunHints;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.font.GlyphList;
	32
	33	/**
	34	* A delegate pipe of SG2D which implements redispatching of
	35	* for the src mode loops in the drawGlyphVector case where
	36	* the installed loop may not match the glyphvector.
	37	*/
	38
	39	public abstract class GlyphListLoopPipe extends GlyphListPipe
	40	implements LoopBasedPipe
	41	{
	42	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl,
	43	int aaHint) {
	44	switch (aaHint) {
	45	case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
	46	sg2d.loops.drawGlyphListLoop.
	47	DrawGlyphList(sg2d, sg2d.surfaceData, gl);
	48	return;
	49	case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
	50	sg2d.loops.drawGlyphListAALoop.
	51	DrawGlyphListAA(sg2d, sg2d.surfaceData, gl);
	52	return;
	53	case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
	54	case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
	55	sg2d.loops.drawGlyphListLCDLoop.
	56	DrawGlyphListLCD(sg2d,sg2d.surfaceData, gl);
	57	return;
	58	}
	59	}
	60	}

java/pkg/sun/java2d/pipe/GlyphListPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/GlyphListPipe.java+147−0

@@ -0,0 +1,147 @@
	1	/*
	2	* Copyright (c) 2000, 2005, 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.java2d.pipe;
	27
	28	import java.awt.Font;
	29	import java.awt.Rectangle;
	30	import java.awt.Shape;
	31	import java.awt.font.FontRenderContext;
	32	import java.awt.font.GlyphVector;
	33	import java.awt.font.TextLayout;
	34
	35	import sun.awt.SunHints;
	36	import sun.java2d.SunGraphics2D;
	37	import sun.java2d.SurfaceData;
	38	import sun.font.GlyphList;
	39	import sun.java2d.loops.FontInfo;
	40
	41	/**
	42	* A delegate pipe of SG2D for drawing text.
	43	*/
	44
	45	public abstract class GlyphListPipe implements TextPipe {
	46
	47	public void drawString(SunGraphics2D sg2d, String s,
	48	double x, double y)
	49	{
	50	FontInfo info = sg2d.getFontInfo();
	51	if (info.pixelHeight > OutlineTextRenderer.THRESHHOLD) {
	52	SurfaceData.outlineTextRenderer.drawString(sg2d, s, x, y);
	53	return;
	54	}
	55
	56	float devx, devy;
	57	if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
	58	double origin[] = {x + info.originX, y + info.originY};
	59	sg2d.transform.transform(origin, 0, origin, 0, 1);
	60	devx = (float)origin[0];
	61	devy = (float)origin[1];
	62	} else {
	63	devx = (float)(x + info.originX + sg2d.transX);
	64	devy = (float)(y + info.originY + sg2d.transY);
	65	}
	66	/* setFromString returns false if shaping is needed, and we then back
	67	* off to a TextLayout. Such text may benefit slightly from a lower
	68	* overhead in this approach over the approach in previous releases.
	69	*/
	70	GlyphList gl = GlyphList.getInstance();
	71	if (gl.setFromString(info, s, devx, devy)) {
	72	drawGlyphList(sg2d, gl);
	73	gl.dispose();
	74	} else {
	75	gl.dispose(); // release this asap.
	76	TextLayout tl = new TextLayout(s, sg2d.getFont(),
	77	sg2d.getFontRenderContext());
	78	tl.draw(sg2d, (float)x, (float)y);
	79	}
	80	}
	81
	82	public void drawChars(SunGraphics2D sg2d,
	83	char data[], int offset, int length,
	84	int ix, int iy)
	85	{
	86	FontInfo info = sg2d.getFontInfo();
	87	float x, y;
	88	if (info.pixelHeight > OutlineTextRenderer.THRESHHOLD) {
	89	SurfaceData.outlineTextRenderer.drawChars(
	90	sg2d, data, offset, length, ix, iy);
	91	return;
	92	}
	93	if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
	94	double origin[] = {ix + info.originX, iy + info.originY};
	95	sg2d.transform.transform(origin, 0, origin, 0, 1);
	96	x = (float) origin[0];
	97	y = (float) origin[1];
	98	} else {
	99	x = ix + info.originX + sg2d.transX;
	100	y = iy + info.originY + sg2d.transY;
	101	}
	102	GlyphList gl = GlyphList.getInstance();
	103	if (gl.setFromChars(info, data, offset, length, x, y)) {
	104	drawGlyphList(sg2d, gl);
	105	gl.dispose();
	106	} else {
	107	gl.dispose(); // release this asap.
	108	TextLayout tl = new TextLayout(new String(data, offset, length),
	109	sg2d.getFont(),
	110	sg2d.getFontRenderContext());
	111	tl.draw(sg2d, ix, iy);
	112
	113	}
	114	}
	115
	116	public void drawGlyphVector(SunGraphics2D sg2d, GlyphVector gv,
	117	float x, float y)
	118	{
	119	FontRenderContext frc = gv.getFontRenderContext();
	120	FontInfo info = sg2d.getGVFontInfo(gv.getFont(), frc);
	121	if (info.pixelHeight > OutlineTextRenderer.THRESHHOLD) {
	122	SurfaceData.outlineTextRenderer.drawGlyphVector(sg2d, gv, x, y);
	123	return;
	124	}
	125	if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
	126	double origin[] = {x, y};
	127	sg2d.transform.transform(origin, 0, origin, 0, 1);
	128	x = (float) origin[0];
	129	y = (float) origin[1];
	130	} else {
	131	x += sg2d.transX; // don't use the glyph info origin, already in gv.
	132	y += sg2d.transY;
	133	}
	134
	135	GlyphList gl = GlyphList.getInstance();
	136	gl.setFromGlyphVector(info, gv, x, y);
	137	drawGlyphList(sg2d, gl, info.aaHint);
	138	gl.dispose();
	139	}
	140
	141	protected abstract void drawGlyphList(SunGraphics2D sg2d, GlyphList gl);
	142
	143	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl,
	144	int aaHint) {
	145	drawGlyphList(sg2d, gl);
	146	}
	147	}

java/pkg/sun/java2d/pipe/LCDTextRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/LCDTextRenderer.java+44−0

@@ -0,0 +1,44 @@
	1	/*
	2	* Copyright (c) 2005, 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.java2d.pipe;
	27
	28	import java.awt.font.GlyphVector;
	29	import sun.java2d.SunGraphics2D;
	30	import sun.font.GlyphList;
	31	import static sun.awt.SunHints.*;
	32
	33	/**
	34	* A delegate pipe of SG2D for drawing LCD text with
	35	* a solid source colour to an opaque destination.
	36	*/
	37
	38	public class LCDTextRenderer extends GlyphListLoopPipe {
	39
	40	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {
	41	sg2d.loops.drawGlyphListLCDLoop.
	42	DrawGlyphListLCD(sg2d, sg2d.surfaceData, gl);
	43	}
	44	}

java/pkg/sun/java2d/pipe/LoopBasedPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/LoopBasedPipe.java+37−0

@@ -0,0 +1,37 @@
	1	/*
	2	* Copyright (c) 2009, 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.java2d.pipe;
	27
	28	/**
	29	* This is a marker interface used by Pipes that need RenderLoops.
	30	* RenderLoops are validated in SurfaceData when a pipe is recognised to
	31	* implement this interface.
	32	*
	33	* @author Mario Torre <neugens@aicas.com>
	34	*/
	35	public interface LoopBasedPipe {
	36
	37	}

java/pkg/sun/java2d/pipe/LoopPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/LoopPipe.java+378−0

@@ -0,0 +1,378 @@
	1	/*
	2	* Copyright (c) 1999, 2010, 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.java2d.pipe;
	27
	28	import java.awt.Font;
	29	import java.awt.Shape;
	30	import java.awt.BasicStroke;
	31	import java.awt.Polygon;
	32	import java.awt.geom.AffineTransform;
	33	import java.awt.geom.PathIterator;
	34	import java.awt.geom.RoundRectangle2D;
	35	import java.awt.geom.Ellipse2D;
	36	import java.awt.geom.Arc2D;
	37	import java.awt.geom.IllegalPathStateException;
	38	import java.awt.geom.Path2D;
	39	import java.awt.font.GlyphVector;
	40	import sun.java2d.SunGraphics2D;
	41	import sun.java2d.SurfaceData;
	42	import sun.java2d.loops.FontInfo;
	43	import sun.java2d.loops.DrawPolygons;
	44	import sun.java2d.loops.FillParallelogram;
	45	import sun.java2d.loops.DrawParallelogram;
	46	import sun.awt.SunHints;
	47
	48	public class LoopPipe
	49	implements PixelDrawPipe,
	50	PixelFillPipe,
	51	ParallelogramPipe,
	52	ShapeDrawPipe,
	53	LoopBasedPipe
	54	{
	55	final static RenderingEngine RenderEngine = RenderingEngine.getInstance();
	56
	57	public void drawLine(SunGraphics2D sg2d,
	58	int x1, int y1, int x2, int y2)
	59	{
	60	int tX = sg2d.transX;
	61	int tY = sg2d.transY;
	62	sg2d.loops.drawLineLoop.DrawLine(sg2d, sg2d.getSurfaceData(),
	63	x1 + tX, y1 + tY,
	64	x2 + tX, y2 + tY);
	65	}
	66
	67	public void drawRect(SunGraphics2D sg2d,
	68	int x, int y, int width, int height)
	69	{
	70	sg2d.loops.drawRectLoop.DrawRect(sg2d, sg2d.getSurfaceData(),
	71	x + sg2d.transX,
	72	y + sg2d.transY,
	73	width, height);
	74	}
	75
	76	public void drawRoundRect(SunGraphics2D sg2d,
	77	int x, int y, int width, int height,
	78	int arcWidth, int arcHeight)
	79	{
	80	sg2d.shapepipe.draw(sg2d,
	81	new RoundRectangle2D.Float(x, y, width, height,
	82	arcWidth, arcHeight));
	83	}
	84
	85	public void drawOval(SunGraphics2D sg2d,
	86	int x, int y, int width, int height)
	87	{
	88	sg2d.shapepipe.draw(sg2d, new Ellipse2D.Float(x, y, width, height));
	89	}
	90
	91	public void drawArc(SunGraphics2D sg2d,
	92	int x, int y, int width, int height,
	93	int startAngle, int arcAngle)
	94	{
	95	sg2d.shapepipe.draw(sg2d, new Arc2D.Float(x, y, width, height,
	96	startAngle, arcAngle,
	97	Arc2D.OPEN));
	98	}
	99
	100	public void drawPolyline(SunGraphics2D sg2d,
	101	int xPoints[], int yPoints[],
	102	int nPoints)
	103	{
	104	int nPointsArray[] = { nPoints };
	105	sg2d.loops.drawPolygonsLoop.DrawPolygons(sg2d, sg2d.getSurfaceData(),
	106	xPoints, yPoints,
	107	nPointsArray, 1,
	108	sg2d.transX, sg2d.transY,
	109	false);
	110	}
	111
	112	public void drawPolygon(SunGraphics2D sg2d,
	113	int xPoints[], int yPoints[],
	114	int nPoints)
	115	{
	116	int nPointsArray[] = { nPoints };
	117	sg2d.loops.drawPolygonsLoop.DrawPolygons(sg2d, sg2d.getSurfaceData(),
	118	xPoints, yPoints,
	119	nPointsArray, 1,
	120	sg2d.transX, sg2d.transY,
	121	true);
	122	}
	123
	124	public void fillRect(SunGraphics2D sg2d,
	125	int x, int y, int width, int height)
	126	{
	127	sg2d.loops.fillRectLoop.FillRect(sg2d, sg2d.getSurfaceData(),
	128	x + sg2d.transX,
	129	y + sg2d.transY,
	130	width, height);
	131	}
	132
	133	public void fillRoundRect(SunGraphics2D sg2d,
	134	int x, int y, int width, int height,
	135	int arcWidth, int arcHeight)
	136	{
	137	sg2d.shapepipe.fill(sg2d,
	138	new RoundRectangle2D.Float(x, y, width, height,
	139	arcWidth, arcHeight));
	140	}
	141
	142	public void fillOval(SunGraphics2D sg2d,
	143	int x, int y, int width, int height)
	144	{
	145	sg2d.shapepipe.fill(sg2d, new Ellipse2D.Float(x, y, width, height));
	146	}
	147
	148	public void fillArc(SunGraphics2D sg2d,
	149	int x, int y, int width, int height,
	150	int startAngle, int arcAngle)
	151	{
	152	sg2d.shapepipe.fill(sg2d, new Arc2D.Float(x, y, width, height,
	153	startAngle, arcAngle,
	154	Arc2D.PIE));
	155	}
	156
	157	public void fillPolygon(SunGraphics2D sg2d,
	158	int xPoints[], int yPoints[],
	159	int nPoints)
	160	{
	161	ShapeSpanIterator sr = getFillSSI(sg2d);
	162
	163	try {
	164	sr.setOutputArea(sg2d.getCompClip());
	165	sr.appendPoly(xPoints, yPoints, nPoints, sg2d.transX, sg2d.transY);
	166	fillSpans(sg2d, sr);
	167	} finally {
	168	sr.dispose();
	169	}
	170	}
	171
	172
	173	public void draw(SunGraphics2D sg2d, Shape s) {
	174	if (sg2d.strokeState == sg2d.STROKE_THIN) {
	175	Path2D.Float p2df;
	176	int transX;
	177	int transY;
	178	if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) {
	179	if (s instanceof Path2D.Float) {
	180	p2df = (Path2D.Float)s;
	181	} else {
	182	p2df = new Path2D.Float(s);
	183	}
	184	transX = sg2d.transX;
	185	transY = sg2d.transY;
	186	} else {
	187	p2df = new Path2D.Float(s, sg2d.transform);
	188	transX = 0;
	189	transY = 0;
	190	}
	191	sg2d.loops.drawPathLoop.DrawPath(sg2d, sg2d.getSurfaceData(),
	192	transX, transY, p2df);
	193	return;
	194	}
	195
	196	if (sg2d.strokeState == sg2d.STROKE_CUSTOM) {
	197	fill(sg2d, sg2d.stroke.createStrokedShape(s));
	198	return;
	199	}
	200
	201	ShapeSpanIterator sr = getStrokeSpans(sg2d, s);
	202
	203	try {
	204	fillSpans(sg2d, sr);
	205	} finally {
	206	sr.dispose();
	207	}
	208	}
	209
	210	/**
	211	* Return a ShapeSpanIterator instance that normalizes as
	212	* appropriate for a fill operation as per the settings in
	213	* the specified SunGraphics2D object.
	214	*
	215	* The ShapeSpanIterator will be newly constructed and ready
	216	* to start taking in geometry.
	217	*
	218	* Note that the caller is responsible for calling dispose()
	219	* on the returned ShapeSpanIterator inside a try/finally block:
	220	* <pre>
	221	* ShapeSpanIterator ssi = LoopPipe.getFillSSI(sg2d);
	222	* try {
	223	* ssi.setOutputArea(clip);
	224	* ssi.appendPath(...); // or appendPoly
	225	* // iterate the spans from ssi and operate on them
	226	* } finally {
	227	* ssi.dispose();
	228	* }
	229	* </pre>
	230	*/
	231	public static ShapeSpanIterator getFillSSI(SunGraphics2D sg2d) {
	232	boolean adjust = ((sg2d.stroke instanceof BasicStroke) &&
	233	sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);
	234	return new ShapeSpanIterator(adjust);
	235	}
	236
	237	/*
	238	* Return a ShapeSpanIterator ready to iterate the spans of the wide
	239	* outline of Shape s using the attributes of the SunGraphics2D
	240	* object.
	241	*
	242	* The ShapeSpanIterator returned will be fully constructed
	243	* and filled with the geometry from the Shape widened by the
	244	* appropriate BasicStroke and normalization parameters taken
	245	* from the SunGraphics2D object and be ready to start returning
	246	* spans.
	247	*
	248	* Note that the caller is responsible for calling dispose()
	249	* on the returned ShapeSpanIterator inside a try/finally block.
	250	* <pre>
	251	* ShapeSpanIterator ssi = LoopPipe.getStrokeSpans(sg2d, s);
	252	* try {
	253	* // iterate the spans from ssi and operate on them
	254	* } finally {
	255	* ssi.dispose();
	256	* }
	257	* </pre>
	258	*
	259	* REMIND: This should return a SpanIterator interface object
	260	* but the caller needs to dispose() the object and that method
	261	* is only on ShapeSpanIterator.
	262	* TODO: Add a dispose() method to the SpanIterator interface.
	263	*/
	264	public static ShapeSpanIterator getStrokeSpans(SunGraphics2D sg2d,
	265	Shape s)
	266	{
	267	ShapeSpanIterator sr = new ShapeSpanIterator(false);
	268
	269	try {
	270	sr.setOutputArea(sg2d.getCompClip());
	271	sr.setRule(PathIterator.WIND_NON_ZERO);
	272
	273	BasicStroke bs = (BasicStroke) sg2d.stroke;
	274	boolean thin = (sg2d.strokeState <= sg2d.STROKE_THINDASHED);
	275	boolean normalize =
	276	(sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);
	277
	278	RenderEngine.strokeTo(s,
	279	sg2d.transform, bs,
	280	thin, normalize, false, sr);
	281	} catch (Throwable t) {
	282	sr.dispose();
	283	sr = null;
	284	t.printStackTrace();
	285	throw new InternalError("Unable to Stroke shape ("+
	286	t.getMessage()+")");
	287	}
	288	return sr;
	289	}
	290
	291	public void fill(SunGraphics2D sg2d, Shape s) {
	292	if (sg2d.strokeState == sg2d.STROKE_THIN) {
	293	Path2D.Float p2df;
	294	int transX;
	295	int transY;
	296	if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) {
	297	if (s instanceof Path2D.Float) {
	298	p2df = (Path2D.Float)s;
	299	} else {
	300	p2df = new Path2D.Float(s);
	301	}
	302	transX = sg2d.transX;
	303	transY = sg2d.transY;
	304	} else {
	305	p2df = new Path2D.Float(s, sg2d.transform);
	306	transX = 0;
	307	transY = 0;
	308	}
	309	sg2d.loops.fillPathLoop.FillPath(sg2d, sg2d.getSurfaceData(),
	310	transX, transY, p2df);
	311	return;
	312	}
	313
	314	ShapeSpanIterator sr = getFillSSI(sg2d);
	315	try {
	316	sr.setOutputArea(sg2d.getCompClip());
	317	AffineTransform at =
	318	((sg2d.transformState == sg2d.TRANSFORM_ISIDENT)
	319	? null
	320	: sg2d.transform);
	321	sr.appendPath(s.getPathIterator(at));
	322	fillSpans(sg2d, sr);
	323	} finally {
	324	sr.dispose();
	325	}
	326	}
	327
	328	private static void fillSpans(SunGraphics2D sg2d, SpanIterator si) {
	329	// REMIND: Eventually, the plan is that it will not be possible for
	330	// fs to be null since the FillSpans loop will be the fundamental
	331	// loop implemented for any destination type...
	332	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	333	si = sg2d.clipRegion.filter(si);
	334	// REMIND: Region.filter produces a Java-only iterator
	335	// with no native counterpart...
	336	} else {
	337	sun.java2d.loops.FillSpans fs = sg2d.loops.fillSpansLoop;
	338	if (fs != null) {
	339	fs.FillSpans(sg2d, sg2d.getSurfaceData(), si);
	340	return;
	341	}
	342	}
	343	int spanbox[] = new int[4];
	344	SurfaceData sd = sg2d.getSurfaceData();
	345	while (si.nextSpan(spanbox)) {
	346	int x = spanbox[0];
	347	int y = spanbox[1];
	348	int w = spanbox[2] - x;
	349	int h = spanbox[3] - y;
	350	sg2d.loops.fillRectLoop.FillRect(sg2d, sd, x, y, w, h);
	351	}
	352	}
	353
	354	public void fillParallelogram(SunGraphics2D sg2d,
	355	double ux1, double uy1,
	356	double ux2, double uy2,
	357	double x, double y,
	358	double dx1, double dy1,
	359	double dx2, double dy2)
	360	{
	361	FillParallelogram fp = sg2d.loops.fillParallelogramLoop;
	362	fp.FillParallelogram(sg2d, sg2d.getSurfaceData(),
	363	x, y, dx1, dy1, dx2, dy2);
	364	}
	365
	366	public void drawParallelogram(SunGraphics2D sg2d,
	367	double ux1, double uy1,
	368	double ux2, double uy2,
	369	double x, double y,
	370	double dx1, double dy1,
	371	double dx2, double dy2,
	372	double lw1, double lw2)
	373	{
	374	DrawParallelogram dp = sg2d.loops.drawParallelogramLoop;
	375	dp.DrawParallelogram(sg2d, sg2d.getSurfaceData(),
	376	x, y, dx1, dy1, dx2, dy2, lw1, lw2);
	377	}
	378	}

java/pkg/sun/java2d/pipe/NullPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/NullPipe.java+155−0

@@ -0,0 +1,155 @@
	1	/*
	2	* Copyright (c) 1997, 2003, 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.java2d.pipe;
	27
	28	import java.awt.Color;
	29	import java.awt.Image;
	30	import java.awt.Shape;
	31	import java.awt.geom.AffineTransform;
	32	import java.awt.image.BufferedImage;
	33	import java.awt.image.BufferedImageOp;
	34	import java.awt.image.ImageObserver;
	35	import java.awt.font.GlyphVector;
	36	import sun.java2d.SunGraphics2D;
	37
	38	/**
	39	* This is a class that implements all of the basic pixel rendering
	40	* methods as NOPs.
	41	* This class is useful for installing as the pipeline when the
	42	* clip is determined to be empty or when the composite operation is
	43	* determined to have no effect (i.e. rule == SRC_OVER, extraAlpha == 0.0).
	44	*/
	45	public class NullPipe
	46	implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe, TextPipe,
	47	DrawImagePipe
	48	{
	49	public void drawLine(SunGraphics2D sg,
	50	int x1, int y1, int x2, int y2) {
	51	}
	52
	53	public void drawRect(SunGraphics2D sg,
	54	int x, int y, int width, int height) {
	55	}
	56
	57	public void fillRect(SunGraphics2D sg,
	58	int x, int y, int width, int height) {
	59	}
	60
	61	public void drawRoundRect(SunGraphics2D sg,
	62	int x, int y, int width, int height,
	63	int arcWidth, int arcHeight) {
	64	}
	65
	66	public void fillRoundRect(SunGraphics2D sg,
	67	int x, int y, int width, int height,
	68	int arcWidth, int arcHeight) {
	69	}
	70
	71	public void drawOval(SunGraphics2D sg,
	72	int x, int y, int width, int height) {
	73	}
	74
	75	public void fillOval(SunGraphics2D sg,
	76	int x, int y, int width, int height) {
	77	}
	78
	79	public void drawArc(SunGraphics2D sg,
	80	int x, int y, int width, int height,
	81	int startAngle, int arcAngle) {
	82	}
	83
	84	public void fillArc(SunGraphics2D sg,
	85	int x, int y, int width, int height,
	86	int startAngle, int arcAngle) {
	87	}
	88
	89	public void drawPolyline(SunGraphics2D sg,
	90	int xPoints[], int yPoints[],
	91	int nPoints) {
	92	}
	93
	94	public void drawPolygon(SunGraphics2D sg,
	95	int xPoints[], int yPoints[],
	96	int nPoints) {
	97	}
	98
	99	public void fillPolygon(SunGraphics2D sg,
	100	int xPoints[], int yPoints[],
	101	int nPoints) {
	102	}
	103
	104	public void draw(SunGraphics2D sg, Shape s) {
	105	}
	106
	107	public void fill(SunGraphics2D sg, Shape s) {
	108	}
	109
	110	public void drawString(SunGraphics2D sg, String s, double x, double y) {
	111	}
	112
	113	public void drawGlyphVector(SunGraphics2D sg, GlyphVector g,
	114	float x, float y) {
	115	}
	116
	117	public void drawChars(SunGraphics2D sg,
	118	char data[], int offset, int length,
	119	int x, int y) {
	120	}
	121
	122	public boolean copyImage(SunGraphics2D sg, Image img,
	123	int x, int y,
	124	Color bgColor,
	125	ImageObserver observer) {
	126	return false;
	127	}
	128	public boolean copyImage(SunGraphics2D sg, Image img,
	129	int dx, int dy, int sx, int sy, int w, int h,
	130	Color bgColor,
	131	ImageObserver observer) {
	132	return false;
	133	}
	134	public boolean scaleImage(SunGraphics2D sg, Image img, int x, int y,
	135	int w, int h,
	136	Color bgColor,
	137	ImageObserver observer) {
	138	return false;
	139	}
	140	public boolean scaleImage(SunGraphics2D sg, Image img,
	141	int dx1, int dy1, int dx2, int dy2,
	142	int sx1, int sy1, int sx2, int sy2,
	143	Color bgColor,
	144	ImageObserver observer) {
	145	return false;
	146	}
	147	public boolean transformImage(SunGraphics2D sg, Image img,
	148	AffineTransform atfm,
	149	ImageObserver observer) {
	150	return false;
	151	}
	152	public void transformImage(SunGraphics2D sg, BufferedImage img,
	153	BufferedImageOp op, int x, int y) {
	154	}
	155	}

java/pkg/sun/java2d/pipe/OutlineTextRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/OutlineTextRenderer.java+145−0

@@ -0,0 +1,145 @@
	1	/*
	2	* Copyright (c) 2000, 2005, 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.java2d.pipe;
	27
	28	import java.awt.font.FontRenderContext;
	29	import java.awt.font.GlyphVector;
	30	import java.awt.font.TextLayout;
	31	import sun.java2d.SunGraphics2D;
	32	import sun.font.GlyphList;
	33	import sun.awt.SunHints;
	34
	35	import java.awt.Shape;
	36	import java.awt.geom.AffineTransform;
	37	import java.awt.font.TextLayout;
	38
	39	/**
	40	* A delegate pipe of SG2D for drawing "large" text with
	41	* a solid source colour to an opaque destination.
	42	* The text is drawn as a filled outline.
	43	* Since the developer is not explicitly requesting this way of
	44	* rendering, this should not be used if the current paint is not
	45	* a solid colour.
	46	*
	47	* If text anti-aliasing is requested by the application, and
	48	* filling path, an anti-aliasing fill pipe needs to
	49	* be invoked.
	50	* This involves making some of the same decisions as in the
	51	* validatePipe call, which may be in a SurfaceData subclass, so
	52	* its awkward to always ensure that the correct pipe is used.
	53	* The easiest thing, rather than reproducing much of that logic
	54	* is to call validatePipe() which works but is expensive, although
	55	* probably not compared to the cost of filling the path.
	56	* Note if AA hint is ON but text-AA hint is OFF this logic will
	57	* produce AA text which perhaps isn't what the user expected.
	58	* Note that the glyphvector obeys its FRC, not the G2D.
	59	*/
	60
	61	public class OutlineTextRenderer implements TextPipe {
	62
	63	// Text with a height greater than the threshhold will be
	64	// drawn via this pipe.
	65	public static final int THRESHHOLD = 100;
	66
	67	public void drawChars(SunGraphics2D g2d,
	68	char data[], int offset, int length,
	69	int x, int y) {
	70
	71	String s = new String(data, offset, length);
	72	drawString(g2d, s, x, y);
	73	}
	74
	75	public void drawString(SunGraphics2D g2d, String str, double x, double y) {
	76
	77	if ("".equals(str)) {
	78	return; // TextLayout constructor throws IAE on "".
	79	}
	80	TextLayout tl = new TextLayout(str, g2d.getFont(),
	81	g2d.getFontRenderContext());
	82	Shape s = tl.getOutline(AffineTransform.getTranslateInstance(x, y));
	83
	84	int textAAHint = g2d.getFontInfo().aaHint;
	85
	86	int prevaaHint = - 1;
	87	if (textAAHint != SunHints.INTVAL_TEXT_ANTIALIAS_OFF &&
	88	g2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {
	89	prevaaHint = g2d.antialiasHint;
	90	g2d.antialiasHint = SunHints.INTVAL_ANTIALIAS_ON;
	91	g2d.validatePipe();
	92	} else if (textAAHint == SunHints.INTVAL_TEXT_ANTIALIAS_OFF
	93	&& g2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_OFF) {
	94	prevaaHint = g2d.antialiasHint;
	95	g2d.antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
	96	g2d.validatePipe();
	97	}
	98
	99	g2d.fill(s);
	100
	101	if (prevaaHint != -1) {
	102	g2d.antialiasHint = prevaaHint;
	103	g2d.validatePipe();
	104	}
	105	}
	106
	107	public void drawGlyphVector(SunGraphics2D g2d, GlyphVector gv,
	108	float x, float y) {
	109
	110
	111	Shape s = gv.getOutline(x, y);
	112	int prevaaHint = - 1;
	113	FontRenderContext frc = gv.getFontRenderContext();
	114	boolean aa = frc.isAntiAliased();
	115
	116	/* aa will be true if any AA mode has been specified.
	117	* ie for LCD and 'gasp' modes too.
	118	* We will check if 'gasp' has resolved AA to be "OFF", and
	119	* in all other cases (ie AA ON and all LCD modes) use AA outlines.
	120	*/
	121	if (aa) {
	122	if (g2d.getGVFontInfo(gv.getFont(), frc).aaHint ==
	123	SunHints.INTVAL_TEXT_ANTIALIAS_OFF) {
	124	aa = false;
	125	}
	126	}
	127
	128	if (aa && g2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {
	129	prevaaHint = g2d.antialiasHint;
	130	g2d.antialiasHint = SunHints.INTVAL_ANTIALIAS_ON;
	131	g2d.validatePipe();
	132	} else if (!aa && g2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_OFF) {
	133	prevaaHint = g2d.antialiasHint;
	134	g2d.antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
	135	g2d.validatePipe();
	136	}
	137
	138	g2d.fill(s);
	139
	140	if (prevaaHint != -1) {
	141	g2d.antialiasHint = prevaaHint;
	142	g2d.validatePipe();
	143	}
	144	}
	145	}

java/pkg/sun/java2d/pipe/ParallelogramPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/ParallelogramPipe.java+76−0

@@ -0,0 +1,76 @@
	1	/*
	2	* Copyright (c) 2008, 2011 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.java2d.pipe;
	27
	28	import sun.java2d.SunGraphics2D;
	29
	30	/**
	31	* This interface defines the set of calls that pipeline objects
	32	* can use to pass on responsibility for drawing arbitrary
	33	* parallelogram shapes.
	34	* Six floating point numbers are provided and the parallelogram
	35	* is defined as the quadrilateral with the following vertices:
	36	* <pre>
	37	* origin: (x, y)
	38	* => (x+dx1, y+dy1)
	39	* => (x+dx1+dx2, y+dy1+dy2)
	40	* => (x+dx2, y+dy2)
	41	* => origin
	42	* </pre>
	43	* The four u[xy][12] parameters are the unsorted extreme coordinates
	44	* of the primitive in user space. They may have been generated by a
	45	* line or a rectangle so they could have u[xy]2 < u[xy]1 in some cases.
	46	* They should be sorted before calculating the bounds of the original
	47	* primitive (such as for calculating the user space bounds for the
	48	* Paint.createContext() method).
	49	*/
	50	public interface ParallelogramPipe {
	51	public void fillParallelogram(SunGraphics2D sg,
	52	double ux1, double uy1,
	53	double ux2, double uy2,
	54	double x, double y,
	55	double dx1, double dy1,
	56	double dx2, double dy2);
	57
	58	/**
	59	* Draw a Parallelogram with the indicated line widths
	60	* assuming a standard BasicStroke with MITER joins.
	61	* lw1 specifies the width of the stroke along the dx1,dy1
	62	* vector and lw2 specifies the width of the stroke along
	63	* the dx2,dy2 vector.
	64	* This is equivalent to outsetting the indicated
	65	* parallelogram by lw/2 pixels, then insetting the
	66	* same parallelogram by lw/2 pixels and filling the
	67	* difference between the outer and inner parallelograms.
	68	*/
	69	public void drawParallelogram(SunGraphics2D sg,
	70	double ux1, double uy1,
	71	double ux2, double uy2,
	72	double x, double y,
	73	double dx1, double dy1,
	74	double dx2, double dy2,
	75	double lw1, double lw2);
	76	}

java/pkg/sun/java2d/pipe/PixelDrawPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/PixelDrawPipe.java+67−0

@@ -0,0 +1,67 @@
	1	/*
	2	* Copyright (c) 1997, 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.java2d.pipe;
	27
	28	import sun.java2d.SunGraphics2D;
	29
	30	/**
	31	* This interface defines the set of calls that pipeline objects
	32	* can use to pass on responsibility for drawing various basic
	33	* geometric figures defined by explicit integer coordinates.
	34	* Typically this interface will be used for communication when
	35	* the coordinates of the rendering have been narrowed down to
	36	* actual device pixels, or for communication of untransformed
	37	* coordinates when the coordinates were specified using integers.
	38	* This interface does not cover all of the rendering calls that
	39	* are possible in Graphics since many of the rendering calls can
	40	* be transformed into one or more variants of these calls.
	41	*/
	42	public interface PixelDrawPipe {
	43	public void drawLine(SunGraphics2D sg,
	44	int x1, int y1, int x2, int y2);
	45
	46	public void drawRect(SunGraphics2D sg,
	47	int x, int y, int width, int height);
	48
	49	public void drawRoundRect(SunGraphics2D sg,
	50	int x, int y, int width, int height,
	51	int arcWidth, int arcHeight);
	52
	53	public void drawOval(SunGraphics2D sg,
	54	int x, int y, int width, int height);
	55
	56	public void drawArc(SunGraphics2D sg,
	57	int x, int y, int width, int height,
	58	int startAngle, int arcAngle);
	59
	60	public void drawPolyline(SunGraphics2D sg,
	61	int xPoints[], int yPoints[],
	62	int nPoints);
	63
	64	public void drawPolygon(SunGraphics2D sg,
	65	int xPoints[], int yPoints[],
	66	int nPoints);
	67	}

java/pkg/sun/java2d/pipe/PixelFillPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/PixelFillPipe.java+61−0

@@ -0,0 +1,61 @@
	1	/*
	2	* Copyright (c) 1997, 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.java2d.pipe;
	27
	28	import sun.java2d.SunGraphics2D;
	29
	30	/**
	31	* This interface defines the set of calls that pipeline objects
	32	* can use to pass on responsibility for filling various basic
	33	* geometric figures defined by explicit integer coordinates.
	34	* Typically this interface will be used for communication when
	35	* the coordinates of the rendering have been narrowed down to
	36	* actual device pixels, or for communication of untransformed
	37	* coordinates when the coordinates were specified using integers.
	38	* This interface does not cover all of the rendering calls that
	39	* are possible in Graphics since many of the rendering calls can
	40	* be transformed into one or more variants of these calls.
	41	*/
	42	public interface PixelFillPipe {
	43	public void fillRect(SunGraphics2D sg,
	44	int x, int y, int width, int height);
	45
	46
	47	public void fillRoundRect(SunGraphics2D sg,
	48	int x, int y, int width, int height,
	49	int arcWidth, int arcHeight);
	50
	51	public void fillOval(SunGraphics2D sg,
	52	int x, int y, int width, int height);
	53
	54	public void fillArc(SunGraphics2D sg,
	55	int x, int y, int width, int height,
	56	int startAngle, int arcAngle);
	57
	58	public void fillPolygon(SunGraphics2D sg,
	59	int xPoints[], int yPoints[],
	60	int nPoints);
	61	}

java/pkg/sun/java2d/pipe/PixelToParallelogramConverter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/PixelToParallelogramConverter.java+429−0

@@ -0,0 +1,429 @@
	1	/*
	2	* Copyright (c) 2008, 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.java2d.pipe;
	27
	28	import java.awt.Shape;
	29	import java.awt.BasicStroke;
	30	import java.awt.geom.Line2D;
	31	import java.awt.geom.Rectangle2D;
	32	import java.awt.geom.AffineTransform;
	33	import sun.java2d.SunGraphics2D;
	34	import sun.awt.SunHints;
	35
	36	/**
	37	* This class converts calls to the basic pixel rendering methods
	38	* into calls to the methods on a ParallelogramPipe.
	39	* Most calls are transformed into calls to the fill(Shape) method
	40	* by the parent PixelToShapeConverter class, but some calls are
	41	* transformed into calls to fill/drawParallelogram().
	42	*/
	43	public class PixelToParallelogramConverter extends PixelToShapeConverter
	44	implements ShapeDrawPipe
	45	{
	46	ParallelogramPipe outrenderer;
	47	double minPenSize;
	48	double normPosition;
	49	double normRoundingBias;
	50	boolean adjustfill;
	51
	52	/**
	53	* @param shapepipe pipeline to forward shape calls to
	54	* @param pgrampipe pipeline to forward parallelogram calls to
	55	* (and drawLine calls if possible)
	56	* @param minPenSize minimum pen size for dropout control
	57	* @param normPosition sub-pixel location to normalize endpoints
	58	* for STROKE_NORMALIZE cases
	59	* @param adjustFill boolean to control whethere normalization
	60	* constants are also applied to fill operations
	61	* (normally true for non-AA, false for AA)
	62	*/
	63	public PixelToParallelogramConverter(ShapeDrawPipe shapepipe,
	64	ParallelogramPipe pgrampipe,
	65	double minPenSize,
	66	double normPosition,
	67	boolean adjustfill)
	68	{
	69	super(shapepipe);
	70	outrenderer = pgrampipe;
	71	this.minPenSize = minPenSize;
	72	this.normPosition = normPosition;
	73	this.normRoundingBias = 0.5 - normPosition;
	74	this.adjustfill = adjustfill;
	75	}
	76
	77	public void drawLine(SunGraphics2D sg2d,
	78	int x1, int y1, int x2, int y2)
	79	{
	80	if (!drawGeneralLine(sg2d, x1, y1, x2, y2)) {
	81	super.drawLine(sg2d, x1, y1, x2, y2);
	82	}
	83	}
	84
	85	public void drawRect(SunGraphics2D sg2d,
	86	int x, int y, int w, int h)
	87	{
	88	if (w >= 0 && h >= 0) {
	89	if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
	90	BasicStroke bs = ((BasicStroke) sg2d.stroke);
	91	if (w > 0 && h > 0) {
	92	if (bs.getLineJoin() == BasicStroke.JOIN_MITER &&
	93	bs.getDashArray() == null)
	94	{
	95	double lw = bs.getLineWidth();
	96	drawRectangle(sg2d, x, y, w, h, lw);
	97	return;
	98	}
	99	} else {
	100	// Note: This calls the integer version which
	101	// will verify that the local drawLine optimizations
	102	// work and call super.drawLine(), if not.
	103	drawLine(sg2d, x, y, x+w, y+h);
	104	return;
	105	}
	106	}
	107	super.drawRect(sg2d, x, y, w, h);
	108	}
	109	}
	110
	111	public void fillRect(SunGraphics2D sg2d,
	112	int x, int y, int w, int h)
	113	{
	114	if (w > 0 && h > 0) {
	115	fillRectangle(sg2d, x, y, w, h);
	116	}
	117	}
	118
	119	public void draw(SunGraphics2D sg2d, Shape s) {
	120	if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
	121	BasicStroke bs = ((BasicStroke) sg2d.stroke);
	122	if (s instanceof Rectangle2D) {
	123	if (bs.getLineJoin() == BasicStroke.JOIN_MITER &&
	124	bs.getDashArray() == null)
	125	{
	126	Rectangle2D r2d = (Rectangle2D) s;
	127	double w = r2d.getWidth();
	128	double h = r2d.getHeight();
	129	double x = r2d.getX();
	130	double y = r2d.getY();
	131	if (w >= 0 && h >= 0) {
	132	double lw = bs.getLineWidth();
	133	drawRectangle(sg2d, x, y, w, h, lw);
	134	}
	135	return;
	136	}
	137	} else if (s instanceof Line2D) {
	138	Line2D l2d = (Line2D) s;
	139	if (drawGeneralLine(sg2d,
	140	l2d.getX1(), l2d.getY1(),
	141	l2d.getX2(), l2d.getY2()))
	142	{
	143	return;
	144	}
	145	}
	146	}
	147
	148	outpipe.draw(sg2d, s);
	149	}
	150
	151	public void fill(SunGraphics2D sg2d, Shape s) {
	152	if (s instanceof Rectangle2D) {
	153	Rectangle2D r2d = (Rectangle2D) s;
	154	double w = r2d.getWidth();
	155	double h = r2d.getHeight();
	156	if (w > 0 && h > 0) {
	157	double x = r2d.getX();
	158	double y = r2d.getY();
	159	fillRectangle(sg2d, x, y, w, h);
	160	}
	161	return;
	162	}
	163
	164	outpipe.fill(sg2d, s);
	165	}
	166
	167	static double len(double x, double y) {
	168	return ((x == 0) ? Math.abs(y)
	169	: ((y == 0) ? Math.abs(x)
	170	: Math.sqrt(x * x + y * y)));
	171	}
	172
	173	double normalize(double v) {
	174	return Math.floor(v + normRoundingBias) + normPosition;
	175	}
	176
	177	public boolean drawGeneralLine(SunGraphics2D sg2d,
	178	double ux1, double uy1,
	179	double ux2, double uy2)
	180	{
	181	if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM \|\|
	182	sg2d.strokeState == SunGraphics2D.STROKE_THINDASHED)
	183	{
	184	return false;
	185	}
	186	BasicStroke bs = (BasicStroke) sg2d.stroke;
	187	int cap = bs.getEndCap();
	188	if (cap == BasicStroke.CAP_ROUND \|\| bs.getDashArray() != null) {
	189	// TODO: we could construct the GeneralPath directly
	190	// for CAP_ROUND and save a lot of processing in that case...
	191	// And again, we would need to deal with dropout control...
	192	return false;
	193	}
	194	double lw = bs.getLineWidth();
	195	// Save the original dx, dy in case we need it to transform
	196	// the linewidth as a perpendicular vector below
	197	double dx = ux2 - ux1;
	198	double dy = uy2 - uy1;
	199	double x1, y1, x2, y2;
	200	switch (sg2d.transformState) {
	201	case SunGraphics2D.TRANSFORM_GENERIC:
	202	case SunGraphics2D.TRANSFORM_TRANSLATESCALE:
	203	{
	204	double coords[] = {ux1, uy1, ux2, uy2};
	205	sg2d.transform.transform(coords, 0, coords, 0, 2);
	206	x1 = coords[0];
	207	y1 = coords[1];
	208	x2 = coords[2];
	209	y2 = coords[3];
	210	}
	211	break;
	212	case SunGraphics2D.TRANSFORM_ANY_TRANSLATE:
	213	case SunGraphics2D.TRANSFORM_INT_TRANSLATE:
	214	{
	215	double tx = sg2d.transform.getTranslateX();
	216	double ty = sg2d.transform.getTranslateY();
	217	x1 = ux1 + tx;
	218	y1 = uy1 + ty;
	219	x2 = ux2 + tx;
	220	y2 = uy2 + ty;
	221	}
	222	break;
	223	case SunGraphics2D.TRANSFORM_ISIDENT:
	224	x1 = ux1;
	225	y1 = uy1;
	226	x2 = ux2;
	227	y2 = uy2;
	228	break;
	229	default:
	230	throw new InternalError("unknown TRANSFORM state...");
	231	}
	232	if (sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE) {
	233	if (sg2d.strokeState == SunGraphics2D.STROKE_THIN &&
	234	outrenderer instanceof PixelDrawPipe)
	235	{
	236	// PixelDrawPipes will add sg2d.transXY so we need to factor
	237	// that out...
	238	int ix1 = (int) Math.floor(x1 - sg2d.transX);
	239	int iy1 = (int) Math.floor(y1 - sg2d.transY);
	240	int ix2 = (int) Math.floor(x2 - sg2d.transX);
	241	int iy2 = (int) Math.floor(y2 - sg2d.transY);
	242	((PixelDrawPipe)outrenderer).drawLine(sg2d, ix1, iy1, ix2, iy2);
	243	return true;
	244	}
	245	x1 = normalize(x1);
	246	y1 = normalize(y1);
	247	x2 = normalize(x2);
	248	y2 = normalize(y2);
	249	}
	250	if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
	251	// Transform the linewidth...
	252	// calculate the scaling factor for a unit vector
	253	// perpendicular to the original user space line.
	254	double len = len(dx, dy);
	255	if (len == 0) {
	256	dx = len = 1;
	257	// dy = 0; already
	258	}
	259	// delta transform the transposed (90 degree rotated) unit vector
	260	double unitvector[] = {dy/len, -dx/len};
	261	sg2d.transform.deltaTransform(unitvector, 0, unitvector, 0, 1);
	262	lw *= len(unitvector[0], unitvector[1]);
	263	}
	264	lw = Math.max(lw, minPenSize);
	265	dx = x2 - x1;
	266	dy = y2 - y1;
	267	double len = len(dx, dy);
	268	double udx, udy;
	269	if (len == 0) {
	270	if (cap == BasicStroke.CAP_BUTT) {
	271	return true;
	272	}
	273	udx = lw;
	274	udy = 0;
	275	} else {
	276	udx = lw * dx / len;
	277	udy = lw * dy / len;
	278	}
	279	double px = x1 + udy / 2.0;
	280	double py = y1 - udx / 2.0;
	281	if (cap == BasicStroke.CAP_SQUARE) {
	282	px -= udx / 2.0;
	283	py -= udy / 2.0;
	284	dx += udx;
	285	dy += udy;
	286	}
	287	outrenderer.fillParallelogram(sg2d, ux1, uy1, ux2, uy2,
	288	px, py, -udy, udx, dx, dy);
	289	return true;
	290	}
	291
	292	public void fillRectangle(SunGraphics2D sg2d,
	293	double rx, double ry,
	294	double rw, double rh)
	295	{
	296	double px, py;
	297	double dx1, dy1, dx2, dy2;
	298	AffineTransform txform = sg2d.transform;
	299	dx1 = txform.getScaleX();
	300	dy1 = txform.getShearY();
	301	dx2 = txform.getShearX();
	302	dy2 = txform.getScaleY();
	303	px = rx * dx1 + ry * dx2 + txform.getTranslateX();
	304	py = rx * dy1 + ry * dy2 + txform.getTranslateY();
	305	dx1 *= rw;
	306	dy1 *= rw;
	307	dx2 *= rh;
	308	dy2 *= rh;
	309	if (adjustfill &&
	310	sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM &&
	311	sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE)
	312	{
	313	double newx = normalize(px);
	314	double newy = normalize(py);
	315	dx1 = normalize(px + dx1) - newx;
	316	dy1 = normalize(py + dy1) - newy;
	317	dx2 = normalize(px + dx2) - newx;
	318	dy2 = normalize(py + dy2) - newy;
	319	px = newx;
	320	py = newy;
	321	}
	322	outrenderer.fillParallelogram(sg2d, rx, ry, rx+rw, ry+rh,
	323	px, py, dx1, dy1, dx2, dy2);
	324	}
	325
	326	public void drawRectangle(SunGraphics2D sg2d,
	327	double rx, double ry,
	328	double rw, double rh,
	329	double lw)
	330	{
	331	double px, py;
	332	double dx1, dy1, dx2, dy2;
	333	double lw1, lw2;
	334	AffineTransform txform = sg2d.transform;
	335	dx1 = txform.getScaleX();
	336	dy1 = txform.getShearY();
	337	dx2 = txform.getShearX();
	338	dy2 = txform.getScaleY();
	339	px = rx * dx1 + ry * dx2 + txform.getTranslateX();
	340	py = rx * dy1 + ry * dy2 + txform.getTranslateY();
	341	// lw along dx1,dy1 scale by transformed length of dx2,dy2 vectors
	342	// and vice versa
	343	lw1 = len(dx1, dy1) * lw;
	344	lw2 = len(dx2, dy2) * lw;
	345	dx1 *= rw;
	346	dy1 *= rw;
	347	dx2 *= rh;
	348	dy2 *= rh;
	349	if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM &&
	350	sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE)
	351	{
	352	double newx = normalize(px);
	353	double newy = normalize(py);
	354	dx1 = normalize(px + dx1) - newx;
	355	dy1 = normalize(py + dy1) - newy;
	356	dx2 = normalize(px + dx2) - newx;
	357	dy2 = normalize(py + dy2) - newy;
	358	px = newx;
	359	py = newy;
	360	}
	361	lw1 = Math.max(lw1, minPenSize);
	362	lw2 = Math.max(lw2, minPenSize);
	363	double len1 = len(dx1, dy1);
	364	double len2 = len(dx2, dy2);
	365	if (lw1 >= len1 \|\| lw2 >= len2) {
	366	// The line widths are large enough to consume the
	367	// entire hole in the middle of the parallelogram
	368	// so we can just fill the outer parallelogram.
	369	fillOuterParallelogram(sg2d,
	370	rx, ry, rx+rw, ry+rh,
	371	px, py, dx1, dy1, dx2, dy2,
	372	len1, len2, lw1, lw2);
	373	} else {
	374	outrenderer.drawParallelogram(sg2d,
	375	rx, ry, rx+rw, ry+rh,
	376	px, py, dx1, dy1, dx2, dy2,
	377	lw1 / len1, lw2 / len2);
	378	}
	379	}
	380
	381	/**
	382	* This utility function handles the case where a drawRectangle
	383	* operation discovered that the interior hole in the rectangle
	384	* or parallelogram has been completely filled in by the stroke
	385	* width. It calculates the outer parallelogram of the stroke
	386	* and issues a single fillParallelogram request to fill it.
	387	*/
	388	public void fillOuterParallelogram(SunGraphics2D sg2d,
	389	double ux1, double uy1,
	390	double ux2, double uy2,
	391	double px, double py,
	392	double dx1, double dy1,
	393	double dx2, double dy2,
	394	double len1, double len2,
	395	double lw1, double lw2)
	396	{
	397	double udx1 = dx1 / len1;
	398	double udy1 = dy1 / len1;
	399	double udx2 = dx2 / len2;
	400	double udy2 = dy2 / len2;
	401	if (len1 == 0) {
	402	// len1 is 0, replace udxy1 with perpendicular of udxy2
	403	if (len2 == 0) {
	404	// both are 0, use a unit Y vector for udxy2
	405	udx2 = 0;
	406	udy2 = 1;
	407	}
	408	udx1 = udy2;
	409	udy1 = -udx2;
	410	} else if (len2 == 0) {
	411	// len2 is 0, replace udxy2 with perpendicular of udxy1
	412	udx2 = udy1;
	413	udy2 = -udx1;
	414	}
	415	udx1 *= lw1;
	416	udy1 *= lw1;
	417	udx2 *= lw2;
	418	udy2 *= lw2;
	419	px -= (udx1 + udx2) / 2;
	420	py -= (udy1 + udy2) / 2;
	421	dx1 += udx1;
	422	dy1 += udy1;
	423	dx2 += udx2;
	424	dy2 += udy2;
	425
	426	outrenderer.fillParallelogram(sg2d, ux1, uy1, ux2, uy2,
	427	px, py, dx1, dy1, dx2, dy2);
	428	}
	429	}

java/pkg/sun/java2d/pipe/PixelToShapeConverter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/PixelToShapeConverter.java+133−0

@@ -0,0 +1,133 @@
	1	/*
	2	* Copyright (c) 1997, 1998, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.Shape;
	30	import java.awt.geom.Arc2D;
	31	import java.awt.geom.Ellipse2D;
	32	import java.awt.geom.Line2D;
	33	import java.awt.geom.RoundRectangle2D;
	34	import java.awt.geom.GeneralPath;
	35	import sun.java2d.SunGraphics2D;
	36
	37	/**
	38	* This class converts calls to the basic pixel rendering methods
	39	* into calls to a generic Shape rendering pipeline.
	40	*/
	41	public class PixelToShapeConverter
	42	implements PixelDrawPipe, PixelFillPipe
	43	{
	44	ShapeDrawPipe outpipe;
	45
	46	public PixelToShapeConverter(ShapeDrawPipe pipe) {
	47	outpipe = pipe;
	48	}
	49
	50	public void drawLine(SunGraphics2D sg,
	51	int x1, int y1, int x2, int y2) {
	52	outpipe.draw(sg, new Line2D.Float(x1, y1, x2, y2));
	53	}
	54
	55	public void drawRect(SunGraphics2D sg,
	56	int x, int y, int w, int h) {
	57	outpipe.draw(sg, new Rectangle(x, y, w, h));
	58	}
	59
	60	public void fillRect(SunGraphics2D sg,
	61	int x, int y, int w, int h) {
	62	outpipe.fill(sg, new Rectangle(x, y, w, h));
	63	}
	64
	65	public void drawRoundRect(SunGraphics2D sg,
	66	int x, int y, int w, int h,
	67	int aW, int aH) {
	68	outpipe.draw(sg, new RoundRectangle2D.Float(x, y, w, h, aW, aH));
	69	}
	70
	71	public void fillRoundRect(SunGraphics2D sg,
	72	int x, int y, int w, int h,
	73	int aW, int aH) {
	74	outpipe.fill(sg, new RoundRectangle2D.Float(x, y, w, h, aW, aH));
	75	}
	76
	77	public void drawOval(SunGraphics2D sg,
	78	int x, int y, int w, int h) {
	79	outpipe.draw(sg, new Ellipse2D.Float(x, y, w, h));
	80	}
	81
	82	public void fillOval(SunGraphics2D sg,
	83	int x, int y, int w, int h) {
	84	outpipe.fill(sg, new Ellipse2D.Float(x, y, w, h));
	85	}
	86
	87	public void drawArc(SunGraphics2D sg,
	88	int x, int y, int w, int h,
	89	int start, int extent) {
	90	outpipe.draw(sg, new Arc2D.Float(x, y, w, h,
	91	start, extent, Arc2D.OPEN));
	92	}
	93
	94	public void fillArc(SunGraphics2D sg,
	95	int x, int y, int w, int h,
	96	int start, int extent) {
	97	outpipe.fill(sg, new Arc2D.Float(x, y, w, h,
	98	start, extent, Arc2D.PIE));
	99	}
	100
	101	private Shape makePoly(int xPoints[], int yPoints[],
	102	int nPoints, boolean close) {
	103	GeneralPath gp = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
	104	if (nPoints > 0) {
	105	gp.moveTo(xPoints[0], yPoints[0]);
	106	}
	107	for (int i = 1; i < nPoints; i++) {
	108	gp.lineTo(xPoints[i], yPoints[i]);
	109	}
	110	if (close) {
	111	gp.closePath();
	112	}
	113	return gp;
	114	}
	115
	116	public void drawPolyline(SunGraphics2D sg,
	117	int xPoints[], int yPoints[],
	118	int nPoints) {
	119	outpipe.draw(sg, makePoly(xPoints, yPoints, nPoints, false));
	120	}
	121
	122	public void drawPolygon(SunGraphics2D sg,
	123	int xPoints[], int yPoints[],
	124	int nPoints) {
	125	outpipe.draw(sg, makePoly(xPoints, yPoints, nPoints, true));
	126	}
	127
	128	public void fillPolygon(SunGraphics2D sg,
	129	int xPoints[], int yPoints[],
	130	int nPoints) {
	131	outpipe.fill(sg, makePoly(xPoints, yPoints, nPoints, true));
	132	}
	133	}

java/pkg/sun/java2d/pipe/Region$ImmutableRegion.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/Region.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/Region.java+1255−0

@@ -0,0 +1,1255 @@
	1	/*
	2	* Copyright (c) 1998, 2006, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.Shape;
	30	import java.awt.geom.AffineTransform;
	31	import java.awt.geom.RectangularShape;
	32
	33	/**
	34	* This class encapsulates a definition of a two dimensional region which
	35	* consists of a number of Y ranges each containing multiple X bands.
	36	* <p>
	37	* A rectangular Region is allowed to have a null band list in which
	38	* case the rectangular shape is defined by the bounding box parameters
	39	* (lox, loy, hix, hiy).
	40	* <p>
	41	* The band list, if present, consists of a list of rows in ascending Y
	42	* order, ending at endIndex which is the index beyond the end of the
	43	* last row. Each row consists of at least 3 + 2n entries (n >= 1)
	44	* where the first 3 entries specify the Y range as start, end, and
	45	* the number of X ranges in that Y range. These 3 entries are
	46	* followed by pairs of X coordinates in ascending order:
	47	* <pre>
	48	* bands[rowstart+0] = Y0; // starting Y coordinate
	49	* bands[rowstart+1] = Y1; // ending Y coordinate - endY > startY
	50	* bands[rowstart+2] = N; // number of X bands - N >= 1
	51	*
	52	* bands[rowstart+3] = X10; // starting X coordinate of first band
	53	* bands[rowstart+4] = X11; // ending X coordinate of first band
	54	* bands[rowstart+5] = X20; // starting X coordinate of second band
	55	* bands[rowstart+6] = X21; // ending X coordinate of second band
	56	* ...
	57	* bands[rowstart+3+N*2-2] = XN0; // starting X coord of last band
	58	* bands[rowstart+3+N*2-1] = XN1; // ending X coord of last band
	59	*
	60	* bands[rowstart+3+N*2] = ... // start of next Y row
	61	* </pre>
	62	*/
	63	public class Region {
	64	static final int INIT_SIZE = 50;
	65	static final int GROW_SIZE = 50;
	66
	67	/**
	68	* Immutable Region.
	69	*/
	70	private static final class ImmutableRegion extends Region {
	71	protected ImmutableRegion(int lox, int loy, int hix, int hiy) {
	72	super(lox, loy, hix, hiy);
	73	}
	74
	75	// Override all the methods that mutate the object
	76	public void appendSpans(sun.java2d.pipe.SpanIterator si) {}
	77	public void setOutputArea(java.awt.Rectangle r) {}
	78	public void setOutputAreaXYWH(int x, int y, int w, int h) {}
	79	public void setOutputArea(int[] box) {}
	80	public void setOutputAreaXYXY(int lox, int loy, int hix, int hiy) {}
	81	}
	82
	83	public static final Region EMPTY_REGION = new ImmutableRegion(0, 0, 0, 0);
	84	public static final Region WHOLE_REGION = new ImmutableRegion(
	85	Integer.MIN_VALUE,
	86	Integer.MIN_VALUE,
	87	Integer.MAX_VALUE,
	88	Integer.MAX_VALUE);
	89
	90	int lox;
	91	int loy;
	92	int hix;
	93	int hiy;
	94
	95	int endIndex;
	96	int[] bands;
	97
	98	private static native void initIDs();
	99
	100	static {
	101	initIDs();
	102	}
	103
	104	/**
	105	* Adds the dimension <code>dim</code> to the coordinate
	106	* <code>start</code> with appropriate clipping. If
	107	* <code>dim</code> is non-positive then the method returns
	108	* the start coordinate. If the sum overflows an integer
	109	* data type then the method returns <code>Integer.MAX_VALUE</code>.
	110	*/
	111	public static int dimAdd(int start, int dim) {
	112	if (dim <= 0) return start;
	113	if ((dim += start) < start) return Integer.MAX_VALUE;
	114	return dim;
	115	}
	116
	117	/**
	118	* Adds the delta {@code dv} to the value {@code v} with
	119	* appropriate clipping to the bounds of Integer resolution.
	120	* If the answer would be greater than {@code Integer.MAX_VALUE}
	121	* then {@code Integer.MAX_VALUE} is returned.
	122	* If the answer would be less than {@code Integer.MIN_VALUE}
	123	* then {@code Integer.MIN_VALUE} is returned.
	124	* Otherwise the sum is returned.
	125	*/
	126	public static int clipAdd(int v, int dv) {
	127	int newv = v + dv;
	128	if ((newv > v) != (dv > 0)) {
	129	newv = (dv < 0) ? Integer.MIN_VALUE : Integer.MAX_VALUE;
	130	}
	131	return newv;
	132	}
	133
	134	protected Region(int lox, int loy, int hix, int hiy) {
	135	this.lox = lox;
	136	this.loy = loy;
	137	this.hix = hix;
	138	this.hiy = hiy;
	139	}
	140
	141	/**
	142	* Returns a Region object covering the pixels which would be
	143	* touched by a fill or clip operation on a Graphics implementation
	144	* on the specified Shape object under the optionally specified
	145	* AffineTransform object.
	146	*
	147	* @param s a non-null Shape object specifying the geometry enclosing
	148	* the pixels of interest
	149	* @param at an optional <code>AffineTransform</code> to be applied to the
	150	* coordinates as they are returned in the iteration, or
	151	* <code>null</code> if untransformed coordinates are desired
	152	*/
	153	public static Region getInstance(Shape s, AffineTransform at) {
	154	return getInstance(WHOLE_REGION, false, s, at);
	155	}
	156
	157	/**
	158	* Returns a Region object covering the pixels which would be
	159	* touched by a fill or clip operation on a Graphics implementation
	160	* on the specified Shape object under the optionally specified
	161	* AffineTransform object further restricted by the specified
	162	* device bounds.
	163	* <p>
	164	* Note that only the bounds of the specified Region are used to
	165	* restrict the resulting Region.
	166	* If devBounds is non-rectangular and clipping to the specific
	167	* bands of devBounds is needed, then an intersection of the
	168	* resulting Region with devBounds must be performed in a
	169	* subsequent step.
	170	*
	171	* @param devBounds a non-null Region specifying some bounds to
	172	* clip the geometry to
	173	* @param s a non-null Shape object specifying the geometry enclosing
	174	* the pixels of interest
	175	* @param at an optional <code>AffineTransform</code> to be applied to the
	176	* coordinates as they are returned in the iteration, or
	177	* <code>null</code> if untransformed coordinates are desired
	178	*/
	179	public static Region getInstance(Region devBounds,
	180	Shape s, AffineTransform at)
	181	{
	182	return getInstance(devBounds, false, s, at);
	183	}
	184
	185	/**
	186	* Returns a Region object covering the pixels which would be
	187	* touched by a fill or clip operation on a Graphics implementation
	188	* on the specified Shape object under the optionally specified
	189	* AffineTransform object further restricted by the specified
	190	* device bounds.
	191	* If the normalize parameter is true then coordinate normalization
	192	* is performed as per the 2D Graphics non-antialiasing implementation
	193	* of the VALUE_STROKE_NORMALIZE hint.
	194	* <p>
	195	* Note that only the bounds of the specified Region are used to
	196	* restrict the resulting Region.
	197	* If devBounds is non-rectangular and clipping to the specific
	198	* bands of devBounds is needed, then an intersection of the
	199	* resulting Region with devBounds must be performed in a
	200	* subsequent step.
	201	*
	202	* @param devBounds a non-null Region specifying some bounds to
	203	* clip the geometry to
	204	* @param normalize a boolean indicating whether or not to apply
	205	* normalization
	206	* @param s a non-null Shape object specifying the geometry enclosing
	207	* the pixels of interest
	208	* @param at an optional <code>AffineTransform</code> to be applied to the
	209	* coordinates as they are returned in the iteration, or
	210	* <code>null</code> if untransformed coordinates are desired
	211	*/
	212	public static Region getInstance(Region devBounds, boolean normalize,
	213	Shape s, AffineTransform at)
	214	{
	215	// Optimize for empty shapes to avoid involving the SpanIterator
	216	if (s instanceof RectangularShape &&
	217	((RectangularShape)s).isEmpty())
	218	{
	219	return EMPTY_REGION;
	220	}
	221
	222	int box[] = new int[4];
	223	ShapeSpanIterator sr = new ShapeSpanIterator(normalize);
	224	try {
	225	sr.setOutputArea(devBounds);
	226	sr.appendPath(s.getPathIterator(at));
	227	sr.getPathBox(box);
	228	Region r = Region.getInstance(box);
	229	r.appendSpans(sr);
	230	return r;
	231	} finally {
	232	sr.dispose();
	233	}
	234	}
	235
	236	/**
	237	* Returns a Region object with a rectangle of interest specified
	238	* by the indicated Rectangle object.
	239	* <p>
	240	* This method can also be used to create a simple rectangular
	241	* region.
	242	*/
	243	public static Region getInstance(Rectangle r) {
	244	return Region.getInstanceXYWH(r.x, r.y, r.width, r.height);
	245	}
	246
	247	/**
	248	* Returns a Region object with a rectangle of interest specified
	249	* by the indicated rectangular area in x, y, width, height format.
	250	* <p>
	251	* This method can also be used to create a simple rectangular
	252	* region.
	253	*/
	254	public static Region getInstanceXYWH(int x, int y, int w, int h) {
	255	return Region.getInstanceXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
	256	}
	257
	258	/**
	259	* Returns a Region object with a rectangle of interest specified
	260	* by the indicated span array.
	261	* <p>
	262	* This method can also be used to create a simple rectangular
	263	* region.
	264	*/
	265	public static Region getInstance(int box[]) {
	266	return new Region(box[0], box[1], box[2], box[3]);
	267	}
	268
	269	/**
	270	* Returns a Region object with a rectangle of interest specified
	271	* by the indicated rectangular area in lox, loy, hix, hiy format.
	272	* <p>
	273	* This method can also be used to create a simple rectangular
	274	* region.
	275	*/
	276	public static Region getInstanceXYXY(int lox, int loy, int hix, int hiy) {
	277	return new Region(lox, loy, hix, hiy);
	278	}
	279
	280	/**
	281	* Sets the rectangle of interest for storing and returning
	282	* region bands.
	283	* <p>
	284	* This method can also be used to initialize a simple rectangular
	285	* region.
	286	*/
	287	public void setOutputArea(Rectangle r) {
	288	setOutputAreaXYWH(r.x, r.y, r.width, r.height);
	289	}
	290
	291	/**
	292	* Sets the rectangle of interest for storing and returning
	293	* region bands. The rectangle is specified in x, y, width, height
	294	* format and appropriate clipping is performed as per the method
	295	* <code>dimAdd</code>.
	296	* <p>
	297	* This method can also be used to initialize a simple rectangular
	298	* region.
	299	*/
	300	public void setOutputAreaXYWH(int x, int y, int w, int h) {
	301	setOutputAreaXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
	302	}
	303
	304	/**
	305	* Sets the rectangle of interest for storing and returning
	306	* region bands. The rectangle is specified as a span array.
	307	* <p>
	308	* This method can also be used to initialize a simple rectangular
	309	* region.
	310	*/
	311	public void setOutputArea(int box[]) {
	312	this.lox = box[0];
	313	this.loy = box[1];
	314	this.hix = box[2];
	315	this.hiy = box[3];
	316	}
	317
	318	/**
	319	* Sets the rectangle of interest for storing and returning
	320	* region bands. The rectangle is specified in lox, loy,
	321	* hix, hiy format.
	322	* <p>
	323	* This method can also be used to initialize a simple rectangular
	324	* region.
	325	*/
	326	public void setOutputAreaXYXY(int lox, int loy, int hix, int hiy) {
	327	this.lox = lox;
	328	this.loy = loy;
	329	this.hix = hix;
	330	this.hiy = hiy;
	331	}
	332
	333	/**
	334	* Appends the list of spans returned from the indicated
	335	* SpanIterator. Each span must be at a higher starting
	336	* Y coordinate than the previous data or it must have a
	337	* Y range equal to the highest Y band in the region and a
	338	* higher X coordinate than any of the spans in that band.
	339	*/
	340	public void appendSpans(SpanIterator si) {
	341	int[] box = new int[6];
	342
	343	while (si.nextSpan(box)) {
	344	appendSpan(box);
	345	}
	346
	347	endRow(box);
	348	calcBBox();
	349	}
	350
	351	/**
	352	* Returns a Region object that represents the same list of
	353	* rectangles as the current Region object, translated by
	354	* the specified dx, dy translation factors.
	355	*/
	356	public Region getTranslatedRegion(int dx, int dy) {
	357	if ((dx \| dy) == 0) {
	358	return this;
	359	}
	360	int tlox = lox + dx;
	361	int tloy = loy + dy;
	362	int thix = hix + dx;
	363	int thiy = hiy + dy;
	364	if ((tlox > lox) != (dx > 0) \|\|
	365	(tloy > loy) != (dy > 0) \|\|
	366	(thix > hix) != (dx > 0) \|\|
	367	(thiy > hiy) != (dy > 0))
	368	{
	369	return getSafeTranslatedRegion(dx, dy);
	370	}
	371	Region ret = new Region(tlox, tloy, thix, thiy);
	372	int bands[] = this.bands;
	373	if (bands != null) {
	374	int end = endIndex;
	375	ret.endIndex = end;
	376	int newbands[] = new int[end];
	377	ret.bands = newbands;
	378	int i = 0;
	379	int ncol;
	380	while (i < end) {
	381	newbands[i] = bands[i] + dy; i++;
	382	newbands[i] = bands[i] + dy; i++;
	383	newbands[i] = ncol = bands[i]; i++;
	384	while (--ncol >= 0) {
	385	newbands[i] = bands[i] + dx; i++;
	386	newbands[i] = bands[i] + dx; i++;
	387	}
	388	}
	389	}
	390	return ret;
	391	}
	392
	393	private Region getSafeTranslatedRegion(int dx, int dy) {
	394	int tlox = clipAdd(lox, dx);
	395	int tloy = clipAdd(loy, dy);
	396	int thix = clipAdd(hix, dx);
	397	int thiy = clipAdd(hiy, dy);
	398	Region ret = new Region(tlox, tloy, thix, thiy);
	399	int bands[] = this.bands;
	400	if (bands != null) {
	401	int end = endIndex;
	402	int newbands[] = new int[end];
	403	int i = 0; // index for source bands
	404	int j = 0; // index for translated newbands
	405	int ncol;
	406	while (i < end) {
	407	int y1, y2;
	408	newbands[j++] = y1 = clipAdd(bands[i++], dy);
	409	newbands[j++] = y2 = clipAdd(bands[i++], dy);
	410	newbands[j++] = ncol = bands[i++];
	411	int savej = j;
	412	if (y1 < y2) {
	413	while (--ncol >= 0) {
	414	int x1 = clipAdd(bands[i++], dx);
	415	int x2 = clipAdd(bands[i++], dx);
	416	if (x1 < x2) {
	417	newbands[j++] = x1;
	418	newbands[j++] = x2;
	419	}
	420	}
	421	} else {
	422	i += ncol * 2;
	423	}
	424	// Did we get any non-empty bands in this row?
	425	if (j > savej) {
	426	newbands[savej-1] = (j - savej) / 2;
	427	} else {
	428	j = savej - 3;
	429	}
	430	}
	431	if (j <= 5) {
	432	if (j < 5) {
	433	// No rows or bands were generated...
	434	ret.lox = ret.loy = ret.hix = ret.hiy = 0;
	435	} else {
	436	// Only generated one single rect in the end...
	437	ret.loy = newbands[0];
	438	ret.hiy = newbands[1];
	439	ret.lox = newbands[3];
	440	ret.hix = newbands[4];
	441	}
	442	// ret.endIndex and ret.bands were never initialized...
	443	// ret.endIndex = 0;
	444	// ret.newbands = null;
	445	} else {
	446	// Generated multiple bands and/or multiple rows...
	447	ret.endIndex = j;
	448	ret.bands = newbands;
	449	}
	450	}
	451	return ret;
	452	}
	453
	454	/**
	455	* Returns a Region object that represents the intersection of
	456	* this object with the specified Rectangle. The return value
	457	* may be this same object if no clipping occurs.
	458	*/
	459	public Region getIntersection(Rectangle r) {
	460	return getIntersectionXYWH(r.x, r.y, r.width, r.height);
	461	}
	462
	463	/**
	464	* Returns a Region object that represents the intersection of
	465	* this object with the specified rectangular area. The return
	466	* value may be this same object if no clipping occurs.
	467	*/
	468	public Region getIntersectionXYWH(int x, int y, int w, int h) {
	469	return getIntersectionXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
	470	}
	471
	472	/**
	473	* Returns a Region object that represents the intersection of
	474	* this object with the specified rectangular area. The return
	475	* value may be this same object if no clipping occurs.
	476	*/
	477	public Region getIntersectionXYXY(int lox, int loy, int hix, int hiy) {
	478	if (isInsideXYXY(lox, loy, hix, hiy)) {
	479	return this;
	480	}
	481	Region ret = new Region((lox < this.lox) ? this.lox : lox,
	482	(loy < this.loy) ? this.loy : loy,
	483	(hix > this.hix) ? this.hix : hix,
	484	(hiy > this.hiy) ? this.hiy : hiy);
	485	if (bands != null) {
	486	ret.appendSpans(this.getSpanIterator());
	487	}
	488	return ret;
	489	}
	490
	491	/**
	492	* Returns a Region object that represents the intersection of this
	493	* object with the specified Region object.
	494	* <p>
	495	* If {@code A} and {@code B} are both Region Objects and
	496	* <code>C = A.getIntersection(B);</code> then a point will
	497	* be contained in {@code C} iff it is contained in both
	498	* {@code A} and {@code B}.
	499	* <p>
	500	* The return value may be this same object or the argument
	501	* Region object if no clipping occurs.
	502	*/
	503	public Region getIntersection(Region r) {
	504	if (this.isInsideQuickCheck(r)) {
	505	return this;
	506	}
	507	if (r.isInsideQuickCheck(this)) {
	508	return r;
	509	}
	510	Region ret = new Region((r.lox < this.lox) ? this.lox : r.lox,
	511	(r.loy < this.loy) ? this.loy : r.loy,
	512	(r.hix > this.hix) ? this.hix : r.hix,
	513	(r.hiy > this.hiy) ? this.hiy : r.hiy);
	514	if (!ret.isEmpty()) {
	515	ret.filterSpans(this, r, INCLUDE_COMMON);
	516	}
	517	return ret;
	518	}
	519
	520	/**
	521	* Returns a Region object that represents the union of this
	522	* object with the specified Region object.
	523	* <p>
	524	* If {@code A} and {@code B} are both Region Objects and
	525	* <code>C = A.getUnion(B);</code> then a point will
	526	* be contained in {@code C} iff it is contained in either
	527	* {@code A} or {@code B}.
	528	* <p>
	529	* The return value may be this same object or the argument
	530	* Region object if no augmentation occurs.
	531	*/
	532	public Region getUnion(Region r) {
	533	if (r.isEmpty() \|\| r.isInsideQuickCheck(this)) {
	534	return this;
	535	}
	536	if (this.isEmpty() \|\| this.isInsideQuickCheck(r)) {
	537	return r;
	538	}
	539	Region ret = new Region((r.lox > this.lox) ? this.lox : r.lox,
	540	(r.loy > this.loy) ? this.loy : r.loy,
	541	(r.hix < this.hix) ? this.hix : r.hix,
	542	(r.hiy < this.hiy) ? this.hiy : r.hiy);
	543	ret.filterSpans(this, r, INCLUDE_A \| INCLUDE_B \| INCLUDE_COMMON);
	544	return ret;
	545	}
	546
	547	/**
	548	* Returns a Region object that represents the difference of the
	549	* specified Region object subtracted from this object.
	550	* <p>
	551	* If {@code A} and {@code B} are both Region Objects and
	552	* <code>C = A.getDifference(B);</code> then a point will
	553	* be contained in {@code C} iff it is contained in
	554	* {@code A} but not contained in {@code B}.
	555	* <p>
	556	* The return value may be this same object or the argument
	557	* Region object if no clipping occurs.
	558	*/
	559	public Region getDifference(Region r) {
	560	if (!r.intersectsQuickCheck(this)) {
	561	return this;
	562	}
	563	if (this.isInsideQuickCheck(r)) {
	564	return EMPTY_REGION;
	565	}
	566	Region ret = new Region(this.lox, this.loy, this.hix, this.hiy);
	567	ret.filterSpans(this, r, INCLUDE_A);
	568	return ret;
	569	}
	570
	571	/**
	572	* Returns a Region object that represents the exclusive or of this
	573	* object with the specified Region object.
	574	* <p>
	575	* If {@code A} and {@code B} are both Region Objects and
	576	* <code>C = A.getExclusiveOr(B);</code> then a point will
	577	* be contained in {@code C} iff it is contained in either
	578	* {@code A} or {@code B}, but not if it is contained in both.
	579	* <p>
	580	* The return value may be this same object or the argument
	581	* Region object if either is empty.
	582	*/
	583	public Region getExclusiveOr(Region r) {
	584	if (r.isEmpty()) {
	585	return this;
	586	}
	587	if (this.isEmpty()) {
	588	return r;
	589	}
	590	Region ret = new Region((r.lox > this.lox) ? this.lox : r.lox,
	591	(r.loy > this.loy) ? this.loy : r.loy,
	592	(r.hix < this.hix) ? this.hix : r.hix,
	593	(r.hiy < this.hiy) ? this.hiy : r.hiy);
	594	ret.filterSpans(this, r, INCLUDE_A \| INCLUDE_B);
	595	return ret;
	596	}
	597
	598	static final int INCLUDE_A = 1;
	599	static final int INCLUDE_B = 2;
	600	static final int INCLUDE_COMMON = 4;
	601
	602	private void filterSpans(Region ra, Region rb, int flags) {
	603	int abands[] = ra.bands;
	604	int bbands[] = rb.bands;
	605	if (abands == null) {
	606	abands = new int[] {ra.loy, ra.hiy, 1, ra.lox, ra.hix};
	607	}
	608	if (bbands == null) {
	609	bbands = new int[] {rb.loy, rb.hiy, 1, rb.lox, rb.hix};
	610	}
	611	int box[] = new int[6];
	612	int acolstart = 0;
	613	int ay1 = abands[acolstart++];
	614	int ay2 = abands[acolstart++];
	615	int acolend = abands[acolstart++];
	616	acolend = acolstart + 2 * acolend;
	617	int bcolstart = 0;
	618	int by1 = bbands[bcolstart++];
	619	int by2 = bbands[bcolstart++];
	620	int bcolend = bbands[bcolstart++];
	621	bcolend = bcolstart + 2 * bcolend;
	622	int y = loy;
	623	while (y < hiy) {
	624	if (y >= ay2) {
	625	if (acolend < ra.endIndex) {
	626	acolstart = acolend;
	627	ay1 = abands[acolstart++];
	628	ay2 = abands[acolstart++];
	629	acolend = abands[acolstart++];
	630	acolend = acolstart + 2 * acolend;
	631	} else {
	632	if ((flags & INCLUDE_B) == 0) break;
	633	ay1 = ay2 = hiy;
	634	}
	635	continue;
	636	}
	637	if (y >= by2) {
	638	if (bcolend < rb.endIndex) {
	639	bcolstart = bcolend;
	640	by1 = bbands[bcolstart++];
	641	by2 = bbands[bcolstart++];
	642	bcolend = bbands[bcolstart++];
	643	bcolend = bcolstart + 2 * bcolend;
	644	} else {
	645	if ((flags & INCLUDE_A) == 0) break;
	646	by1 = by2 = hiy;
	647	}
	648	continue;
	649	}
	650	int yend;
	651	if (y < by1) {
	652	if (y < ay1) {
	653	y = Math.min(ay1, by1);
	654	continue;
	655	}
	656	// We are in a set of rows that belong only to A
	657	yend = Math.min(ay2, by1);
	658	if ((flags & INCLUDE_A) != 0) {
	659	box[1] = y;
	660	box[3] = yend;
	661	int acol = acolstart;
	662	while (acol < acolend) {
	663	box[0] = abands[acol++];
	664	box[2] = abands[acol++];
	665	appendSpan(box);
	666	}
	667	}
	668	} else if (y < ay1) {
	669	// We are in a set of rows that belong only to B
	670	yend = Math.min(by2, ay1);
	671	if ((flags & INCLUDE_B) != 0) {
	672	box[1] = y;
	673	box[3] = yend;
	674	int bcol = bcolstart;
	675	while (bcol < bcolend) {
	676	box[0] = bbands[bcol++];
	677	box[2] = bbands[bcol++];
	678	appendSpan(box);
	679	}
	680	}
	681	} else {
	682	// We are in a set of rows that belong to both A and B
	683	yend = Math.min(ay2, by2);
	684	box[1] = y;
	685	box[3] = yend;
	686	int acol = acolstart;
	687	int bcol = bcolstart;
	688	int ax1 = abands[acol++];
	689	int ax2 = abands[acol++];
	690	int bx1 = bbands[bcol++];
	691	int bx2 = bbands[bcol++];
	692	int x = Math.min(ax1, bx1);
	693	if (x < lox) x = lox;
	694	while (x < hix) {
	695	if (x >= ax2) {
	696	if (acol < acolend) {
	697	ax1 = abands[acol++];
	698	ax2 = abands[acol++];
	699	} else {
	700	if ((flags & INCLUDE_B) == 0) break;
	701	ax1 = ax2 = hix;
	702	}
	703	continue;
	704	}
	705	if (x >= bx2) {
	706	if (bcol < bcolend) {
	707	bx1 = bbands[bcol++];
	708	bx2 = bbands[bcol++];
	709	} else {
	710	if ((flags & INCLUDE_A) == 0) break;
	711	bx1 = bx2 = hix;
	712	}
	713	continue;
	714	}
	715	int xend;
	716	boolean appendit;
	717	if (x < bx1) {
	718	if (x < ax1) {
	719	xend = Math.min(ax1, bx1);
	720	appendit = false;
	721	} else {
	722	xend = Math.min(ax2, bx1);
	723	appendit = ((flags & INCLUDE_A) != 0);
	724	}
	725	} else if (x < ax1) {
	726	xend = Math.min(ax1, bx2);
	727	appendit = ((flags & INCLUDE_B) != 0);
	728	} else {
	729	xend = Math.min(ax2, bx2);
	730	appendit = ((flags & INCLUDE_COMMON) != 0);
	731	}
	732	if (appendit) {
	733	box[0] = x;
	734	box[2] = xend;
	735	appendSpan(box);
	736	}
	737	x = xend;
	738	}
	739	}
	740	y = yend;
	741	}
	742	endRow(box);
	743	calcBBox();
	744	}
	745
	746	/**
	747	* Returns a Region object that represents the bounds of the
	748	* intersection of this object with the bounds of the specified
	749	* Region object.
	750	* <p>
	751	* The return value may be this same object if no clipping occurs
	752	* and this Region is rectangular.
	753	*/
	754	public Region getBoundsIntersection(Rectangle r) {
	755	return getBoundsIntersectionXYWH(r.x, r.y, r.width, r.height);
	756	}
	757
	758	/**
	759	* Returns a Region object that represents the bounds of the
	760	* intersection of this object with the bounds of the specified
	761	* rectangular area in x, y, width, height format.
	762	* <p>
	763	* The return value may be this same object if no clipping occurs
	764	* and this Region is rectangular.
	765	*/
	766	public Region getBoundsIntersectionXYWH(int x, int y, int w, int h) {
	767	return getBoundsIntersectionXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
	768	}
	769
	770	/**
	771	* Returns a Region object that represents the bounds of the
	772	* intersection of this object with the bounds of the specified
	773	* rectangular area in lox, loy, hix, hiy format.
	774	* <p>
	775	* The return value may be this same object if no clipping occurs
	776	* and this Region is rectangular.
	777	*/
	778	public Region getBoundsIntersectionXYXY(int lox, int loy,
	779	int hix, int hiy)
	780	{
	781	if (this.bands == null &&
	782	this.lox >= lox && this.loy >= loy &&
	783	this.hix <= hix && this.hiy <= hiy)
	784	{
	785	return this;
	786	}
	787	return new Region((lox < this.lox) ? this.lox : lox,
	788	(loy < this.loy) ? this.loy : loy,
	789	(hix > this.hix) ? this.hix : hix,
	790	(hiy > this.hiy) ? this.hiy : hiy);
	791	}
	792
	793	/**
	794	* Returns a Region object that represents the intersection of
	795	* this object with the bounds of the specified Region object.
	796	* <p>
	797	* The return value may be this same object or the argument
	798	* Region object if no clipping occurs and the Regions are
	799	* rectangular.
	800	*/
	801	public Region getBoundsIntersection(Region r) {
	802	if (this.encompasses(r)) {
	803	return r;
	804	}
	805	if (r.encompasses(this)) {
	806	return this;
	807	}
	808	return new Region((r.lox < this.lox) ? this.lox : r.lox,
	809	(r.loy < this.loy) ? this.loy : r.loy,
	810	(r.hix > this.hix) ? this.hix : r.hix,
	811	(r.hiy > this.hiy) ? this.hiy : r.hiy);
	812	}
	813
	814	/**
	815	* Appends a single span defined by the 4 parameters
	816	* spanlox, spanloy, spanhix, spanhiy.
	817	* This span must be at a higher starting Y coordinate than
	818	* the previous data or it must have a Y range equal to the
	819	* highest Y band in the region and a higher X coordinate
	820	* than any of the spans in that band.
	821	*/
	822	private void appendSpan(int box[]) {
	823	int spanlox, spanloy, spanhix, spanhiy;
	824	if ((spanlox = box[0]) < lox) spanlox = lox;
	825	if ((spanloy = box[1]) < loy) spanloy = loy;
	826	if ((spanhix = box[2]) > hix) spanhix = hix;
	827	if ((spanhiy = box[3]) > hiy) spanhiy = hiy;
	828	if (spanhix <= spanlox \|\| spanhiy <= spanloy) {
	829	return;
	830	}
	831
	832	int curYrow = box[4];
	833	if (endIndex == 0 \|\| spanloy >= bands[curYrow + 1]) {
	834	if (bands == null) {
	835	bands = new int[INIT_SIZE];
	836	} else {
	837	needSpace(5);
	838	endRow(box);
	839	curYrow = box[4];
	840	}
	841	bands[endIndex++] = spanloy;
	842	bands[endIndex++] = spanhiy;
	843	bands[endIndex++] = 0;
	844	} else if (spanloy == bands[curYrow] &&
	845	spanhiy == bands[curYrow + 1] &&
	846	spanlox >= bands[endIndex - 1]) {
	847	if (spanlox == bands[endIndex - 1]) {
	848	bands[endIndex - 1] = spanhix;
	849	return;
	850	}
	851	needSpace(2);
	852	} else {
	853	throw new InternalError("bad span");
	854	}
	855	bands[endIndex++] = spanlox;
	856	bands[endIndex++] = spanhix;
	857	bands[curYrow + 2]++;
	858	}
	859
	860	private void needSpace(int num) {
	861	if (endIndex + num >= bands.length) {
	862	int[] newbands = new int[bands.length + GROW_SIZE];
	863	System.arraycopy(bands, 0, newbands, 0, endIndex);
	864	bands = newbands;
	865	}
	866	}
	867
	868	private void endRow(int box[]) {
	869	int cur = box[4];
	870	int prev = box[5];
	871	if (cur > prev) {
	872	int[] bands = this.bands;
	873	if (bands[prev + 1] == bands[cur] &&
	874	bands[prev + 2] == bands[cur + 2])
	875	{
	876	int num = bands[cur + 2] * 2;
	877	cur += 3;
	878	prev += 3;
	879	while (num > 0) {
	880	if (bands[cur++] != bands[prev++]) {
	881	break;
	882	}
	883	num--;
	884	}
	885	if (num == 0) {
	886	// prev == box[4]
	887	bands[box[5] + 1] = bands[prev + 1];
	888	endIndex = prev;
	889	return;
	890	}
	891	}
	892	}
	893	box[5] = box[4];
	894	box[4] = endIndex;
	895	}
	896
	897	private void calcBBox() {
	898	int[] bands = this.bands;
	899	if (endIndex <= 5) {
	900	if (endIndex == 0) {
	901	lox = loy = hix = hiy = 0;
	902	} else {
	903	loy = bands[0];
	904	hiy = bands[1];
	905	lox = bands[3];
	906	hix = bands[4];
	907	endIndex = 0;
	908	}
	909	this.bands = null;
	910	return;
	911	}
	912	int lox = this.hix;
	913	int hix = this.lox;
	914	int hiyindex = 0;
	915
	916	int i = 0;
	917	while (i < endIndex) {
	918	hiyindex = i;
	919	int numbands = bands[i + 2];
	920	i += 3;
	921	if (lox > bands[i]) {
	922	lox = bands[i];
	923	}
	924	i += numbands * 2;
	925	if (hix < bands[i - 1]) {
	926	hix = bands[i - 1];
	927	}
	928	}
	929
	930	this.lox = lox;
	931	this.loy = bands[0];
	932	this.hix = hix;
	933	this.hiy = bands[hiyindex + 1];
	934	}
	935
	936	/**
	937	* Returns the lowest X coordinate in the Region.
	938	*/
	939	public final int getLoX() {
	940	return lox;
	941	}
	942
	943	/**
	944	* Returns the lowest Y coordinate in the Region.
	945	*/
	946	public final int getLoY() {
	947	return loy;
	948	}
	949
	950	/**
	951	* Returns the highest X coordinate in the Region.
	952	*/
	953	public final int getHiX() {
	954	return hix;
	955	}
	956
	957	/**
	958	* Returns the highest Y coordinate in the Region.
	959	*/
	960	public final int getHiY() {
	961	return hiy;
	962	}
	963
	964	/**
	965	* Returns the width of this Region clipped to the range (0 - MAX_INT).
	966	*/
	967	public final int getWidth() {
	968	if (hix < lox) return 0;
	969	int w;
	970	if ((w = hix - lox) < 0) {
	971	w = Integer.MAX_VALUE;
	972	}
	973	return w;
	974	}
	975
	976	/**
	977	* Returns the height of this Region clipped to the range (0 - MAX_INT).
	978	*/
	979	public final int getHeight() {
	980	if (hiy < loy) return 0;
	981	int h;
	982	if ((h = hiy - loy) < 0) {
	983	h = Integer.MAX_VALUE;
	984	}
	985	return h;
	986	}
	987
	988	/**
	989	* Returns true iff this Region encloses no area.
	990	*/
	991	public boolean isEmpty() {
	992	return (hix <= lox \|\| hiy <= loy);
	993	}
	994
	995	/**
	996	* Returns true iff this Region represents a single simple
	997	* rectangular area.
	998	*/
	999	public boolean isRectangular() {
	1000	return (bands == null);
	1001	}
	1002
	1003	/**
	1004	* Returns true iff this Region contains the specified coordinate.
	1005	*/
	1006	public boolean contains(int x, int y) {
	1007	if (x < lox \|\| x >= hix \|\| y < loy \|\| y >= hiy) return false;
	1008	if (bands == null) return true;
	1009	int i = 0;
	1010	while (i < endIndex) {
	1011	if (y < bands[i++]) {
	1012	return false;
	1013	}
	1014	if (y >= bands[i++]) {
	1015	int numspans = bands[i++];
	1016	i += numspans * 2;
	1017	} else {
	1018	int end = bands[i++];
	1019	end = i + end * 2;
	1020	while (i < end) {
	1021	if (x < bands[i++]) return false;
	1022	if (x < bands[i++]) return true;
	1023	}
	1024	return false;
	1025	}
	1026	}
	1027	return false;
	1028	}
	1029
	1030	/**
	1031	* Returns true iff this Region lies inside the indicated
	1032	* rectangular area specified in x, y, width, height format
	1033	* with appropriate clipping performed as per the dimAdd method.
	1034	*/
	1035	public boolean isInsideXYWH(int x, int y, int w, int h) {
	1036	return isInsideXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
	1037	}
	1038
	1039	/**
	1040	* Returns true iff this Region lies inside the indicated
	1041	* rectangular area specified in lox, loy, hix, hiy format.
	1042	*/
	1043	public boolean isInsideXYXY(int lox, int loy, int hix, int hiy) {
	1044	return (this.lox >= lox && this.loy >= loy &&
	1045	this.hix <= hix && this.hiy <= hiy);
	1046
	1047	}
	1048
	1049	/**
	1050	* Quickly checks if this Region lies inside the specified
	1051	* Region object.
	1052	* <p>
	1053	* This method will return false if the specified Region
	1054	* object is not a simple rectangle.
	1055	*/
	1056	public boolean isInsideQuickCheck(Region r) {
	1057	return (r.bands == null &&
	1058	r.lox <= this.lox && r.loy <= this.loy &&
	1059	r.hix >= this.hix && r.hiy >= this.hiy);
	1060	}
	1061
	1062	/**
	1063	* Quickly checks if this Region intersects the specified
	1064	* rectangular area specified in lox, loy, hix, hiy format.
	1065	* <p>
	1066	* This method tests only against the bounds of this region
	1067	* and does not bother to test if the rectangular region
	1068	* actually intersects any bands.
	1069	*/
	1070	public boolean intersectsQuickCheckXYXY(int lox, int loy,
	1071	int hix, int hiy)
	1072	{
	1073	return (hix > this.lox && lox < this.hix &&
	1074	hiy > this.loy && loy < this.hiy);
	1075	}
	1076
	1077	/**
	1078	* Quickly checks if this Region intersects the specified
	1079	* Region object.
	1080	* <p>
	1081	* This method tests only against the bounds of this region
	1082	* and does not bother to test if the rectangular region
	1083	* actually intersects any bands.
	1084	*/
	1085	public boolean intersectsQuickCheck(Region r) {
	1086	return (r.hix > this.lox && r.lox < this.hix &&
	1087	r.hiy > this.loy && r.loy < this.hiy);
	1088	}
	1089
	1090	/**
	1091	* Quickly checks if this Region surrounds the specified
	1092	* Region object.
	1093	* <p>
	1094	* This method will return false if this Region object is
	1095	* not a simple rectangle.
	1096	*/
	1097	public boolean encompasses(Region r) {
	1098	return (this.bands == null &&
	1099	this.lox <= r.lox && this.loy <= r.loy &&
	1100	this.hix >= r.hix && this.hiy >= r.hiy);
	1101	}
	1102
	1103	/**
	1104	* Quickly checks if this Region surrounds the specified
	1105	* rectangular area specified in x, y, width, height format.
	1106	* <p>
	1107	* This method will return false if this Region object is
	1108	* not a simple rectangle.
	1109	*/
	1110	public boolean encompassesXYWH(int x, int y, int w, int h) {
	1111	return encompassesXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
	1112	}
	1113
	1114	/**
	1115	* Quickly checks if this Region surrounds the specified
	1116	* rectangular area specified in lox, loy, hix, hiy format.
	1117	* <p>
	1118	* This method will return false if this Region object is
	1119	* not a simple rectangle.
	1120	*/
	1121	public boolean encompassesXYXY(int lox, int loy, int hix, int hiy) {
	1122	return (this.bands == null &&
	1123	this.lox <= lox && this.loy <= loy &&
	1124	this.hix >= hix && this.hiy >= hiy);
	1125	}
	1126
	1127	/**
	1128	* Gets the bbox of the available spans, clipped to the OutputArea.
	1129	*/
	1130	public void getBounds(int pathbox[]) {
	1131	pathbox[0] = lox;
	1132	pathbox[1] = loy;
	1133	pathbox[2] = hix;
	1134	pathbox[3] = hiy;
	1135	}
	1136
	1137	/**
	1138	* Clips the indicated bbox array to the bounds of this Region.
	1139	*/
	1140	public void clipBoxToBounds(int bbox[]) {
	1141	if (bbox[0] < lox) bbox[0] = lox;
	1142	if (bbox[1] < loy) bbox[1] = loy;
	1143	if (bbox[2] > hix) bbox[2] = hix;
	1144	if (bbox[3] > hiy) bbox[3] = hiy;
	1145	}
	1146
	1147	/**
	1148	* Gets an iterator object to iterate over the spans in this region.
	1149	*/
	1150	public RegionIterator getIterator() {
	1151	return new RegionIterator(this);
	1152	}
	1153
	1154	/**
	1155	* Gets a span iterator object that iterates over the spans in this region
	1156	*/
	1157	public SpanIterator getSpanIterator() {
	1158	return new RegionSpanIterator(this);
	1159	}
	1160
	1161	/**
	1162	* Gets a span iterator object that iterates over the spans in this region
	1163	* but clipped to the bounds given in the argument (xlo, ylo, xhi, yhi).
	1164	*/
	1165	public SpanIterator getSpanIterator(int bbox[]) {
	1166	SpanIterator result = getSpanIterator();
	1167	result.intersectClipBox(bbox[0], bbox[1], bbox[2], bbox[3]);
	1168	return result;
	1169	}
	1170
	1171	/**
	1172	* Returns a SpanIterator that is the argument iterator filtered by
	1173	* this region.
	1174	*/
	1175	public SpanIterator filter(SpanIterator si) {
	1176	if (bands == null) {
	1177	si.intersectClipBox(lox, loy, hix, hiy);
	1178	} else {
	1179	si = new RegionClipSpanIterator(this, si);
	1180	}
	1181	return si;
	1182	}
	1183
	1184	public String toString() {
	1185	StringBuffer sb = new StringBuffer();
	1186	sb.append("Region[[");
	1187	sb.append(lox);
	1188	sb.append(", ");
	1189	sb.append(loy);
	1190	sb.append(" => ");
	1191	sb.append(hix);
	1192	sb.append(", ");
	1193	sb.append(hiy);
	1194	sb.append("]");
	1195	if (bands != null) {
	1196	int col = 0;
	1197	while (col < endIndex) {
	1198	sb.append("y{");
	1199	sb.append(bands[col++]);
	1200	sb.append(",");
	1201	sb.append(bands[col++]);
	1202	sb.append("}[");
	1203	int end = bands[col++];
	1204	end = col + end * 2;
	1205	while (col < end) {
	1206	sb.append("x(");
	1207	sb.append(bands[col++]);
	1208	sb.append(", ");
	1209	sb.append(bands[col++]);
	1210	sb.append(")");
	1211	}
	1212	sb.append("]");
	1213	}
	1214	}
	1215	sb.append("]");
	1216	return sb.toString();
	1217	}
	1218
	1219	public int hashCode() {
	1220	return (isEmpty() ? 0 : (lox * 3 + loy * 5 + hix * 7 + hiy * 9));
	1221	}
	1222
	1223	public boolean equals(Object o) {
	1224	if (!(o instanceof Region)) {
	1225	return false;
	1226	}
	1227	Region r = (Region) o;
	1228	if (this.isEmpty()) {
	1229	return r.isEmpty();
	1230	} else if (r.isEmpty()) {
	1231	return false;
	1232	}
	1233	if (r.lox != this.lox \|\| r.loy != this.loy \|\|
	1234	r.hix != this.hix \|\| r.hiy != this.hiy)
	1235	{
	1236	return false;
	1237	}
	1238	if (this.bands == null) {
	1239	return (r.bands == null);
	1240	} else if (r.bands == null) {
	1241	return false;
	1242	}
	1243	if (this.endIndex != r.endIndex) {
	1244	return false;
	1245	}
	1246	int abands[] = this.bands;
	1247	int bbands[] = r.bands;
	1248	for (int i = 0; i < endIndex; i++) {
	1249	if (abands[i] != bbands[i]) {
	1250	return false;
	1251	}
	1252	}
	1253	return true;
	1254	}
	1255	}

java/pkg/sun/java2d/pipe/RegionClipSpanIterator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RegionClipSpanIterator.java+392−0

@@ -0,0 +1,392 @@
	1	/*
	2	* Copyright (c) 1999, 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.java2d.pipe;
	27
	28	import java.awt.geom.PathIterator;
	29	import java.awt.Rectangle;
	30
	31	/**
	32	* This class clips a SpanIterator to a Region and outputs the
	33	* resulting spans as another SpanIterator.
	34	*
	35	* Spans are output in the usual y/x order, unless the input span
	36	* iterator doesn't conform to this order, or the iterator's span
	37	* straddle more than one band of the Region used for clipping.
	38	*
	39	* Principle of operation:
	40	*
	41	* The iterator maintains a several cursors onto the RegionIterator
	42	* in order to avoid having to buffer spans from the SpanIterator.
	43	* They are:
	44	* resetState The initial state of the RegionIterator
	45	* lwm Low Water Mark, a running start point for
	46	* processing each band. Usually goes down, but
	47	* can be reset to resetState if a span has a lower
	48	* start coordinate than the previous one.
	49	* row The start of the current band of the RegionIterator
	50	* box The current span of the current row
	51	*
	52	* The main nextSpan() loop implements a coroutine like structure, with
	53	* three producers to get the next span, row and box calling each other
	54	* to iterate through the span iterator and region.
	55	*
	56	* REMIND: Needs a native implementation!
	57	*/
	58	public class RegionClipSpanIterator implements SpanIterator {
	59
	60	// The inputs to the filter
	61	Region rgn;
	62	SpanIterator spanIter;
	63
	64	// The cursors that track the progress through the region
	65	RegionIterator resetState;
	66	RegionIterator lwm;
	67	RegionIterator row;
	68	RegionIterator box;
	69
	70	// The bounds of the current span iterator span
	71	int spanlox, spanhix, spanloy, spanhiy;
	72
	73	// The extent of the region band marking the low water mark
	74	int lwmloy, lwmhiy;
	75
	76	// The bounds of the current region box
	77	int rgnlox, rgnloy, rgnhix, rgnhiy;
	78
	79	// The bounding box of the input Region. Used for click
	80	// rejection of iterator spans
	81	int rgnbndslox, rgnbndsloy, rgnbndshix, rgnbndshiy;
	82
	83	// The array used to hold coordinates from the region iterator
	84	int rgnbox[] = new int[4];
	85
	86	// The array used to hold coordinates from the span iterator
	87	int spanbox[] = new int[4];
	88
	89	// True if the next iterator span should be read on the next
	90	// iteration of the main nextSpan() loop
	91	boolean doNextSpan;
	92
	93	// True if the next region box should be read on the next
	94	// iteration of the main nextSpan() loop
	95	boolean doNextBox;
	96
	97	// True if there are no more spans or the Region is empty
	98	boolean done = false;
	99
	100	/*
	101	* Creates an instance that filters the spans generated by
	102	* spanIter through the region described by rgn.
	103	*/
	104	public RegionClipSpanIterator(Region rgn, SpanIterator spanIter) {
	105
	106	this.spanIter = spanIter;
	107
	108	resetState = rgn.getIterator();
	109	lwm = resetState.createCopy();
	110
	111	if (!lwm.nextYRange(rgnbox)) {
	112	done = true;
	113	return;
	114	}
	115
	116	rgnloy = lwmloy = rgnbox[1];
	117	rgnhiy = lwmhiy = rgnbox[3];
	118
	119	rgn.getBounds(rgnbox);
	120	rgnbndslox = rgnbox[0];
	121	rgnbndsloy = rgnbox[1];
	122	rgnbndshix = rgnbox[2];
	123	rgnbndshiy = rgnbox[3];
	124	if (rgnbndslox >= rgnbndshix \|\|
	125	rgnbndsloy >= rgnbndshiy) {
	126	done = true;
	127	return;
	128	}
	129
	130	this.rgn = rgn;
	131
	132
	133	row = lwm.createCopy();
	134	box = row.createCopy();
	135	doNextSpan = true;
	136	doNextBox = false;
	137	}
	138
	139	/*
	140	* Gets the bbox of the available path segments, clipped to the
	141	* Region.
	142	*/
	143	public void getPathBox(int pathbox[]) {
	144	int[] rgnbox = new int[4];
	145	rgn.getBounds(rgnbox);
	146	spanIter.getPathBox(pathbox);
	147
	148	if (pathbox[0] < rgnbox[0]) {
	149	pathbox[0] = rgnbox[0];
	150	}
	151
	152	if (pathbox[1] < rgnbox[1]) {
	153	pathbox[1] = rgnbox[1];
	154	}
	155
	156	if (pathbox[2] > rgnbox[2]) {
	157	pathbox[2] = rgnbox[2];
	158	}
	159
	160	if (pathbox[3] > rgnbox[3]) {
	161	pathbox[3] = rgnbox[3];
	162	}
	163	}
	164
	165	/*
	166	* Intersects the path box with the given bbox.
	167	* Returned spans are clipped to this region, or discarded
	168	* altogether if they lie outside it.
	169	*/
	170	public void intersectClipBox(int lox, int loy, int hix, int hiy) {
	171	spanIter.intersectClipBox(lox, loy, hix, hiy);
	172	}
	173
	174
	175	/*
	176	* Fetches the next span that needs to be operated on.
	177	* If the return value is false then there are no more spans.
	178	*/
	179	public boolean nextSpan(int resultbox[]) {
	180	if (done) {
	181	return false;
	182	}
	183
	184	int resultlox, resultloy, resulthix, resulthiy;
	185	boolean doNextRow = false;
	186
	187	// REMIND: Cache the coordinate inst vars used in this loop
	188	// in locals vars.
	189	while (true) {
	190	// We've exhausted the current span so get the next one
	191	if (doNextSpan) {
	192	if (!spanIter.nextSpan(spanbox)) {
	193	done = true;
	194	return false;
	195	} else {
	196	spanlox = spanbox[0];
	197	// Clip out spans that lie outside of the rgn's bounds
	198	if (spanlox >= rgnbndshix) {
	199	continue;
	200	}
	201
	202	spanloy = spanbox[1];
	203	if (spanloy >= rgnbndshiy) {
	204	continue;
	205	}
	206
	207	spanhix = spanbox[2];
	208	if (spanhix <= rgnbndslox) {
	209	continue;
	210	}
	211
	212	spanhiy = spanbox[3];
	213	if (spanhiy <= rgnbndsloy) {
	214	continue;
	215	}
	216	}
	217	// If the span starts higher up than the low-water mark,
	218	// reset the lwm. This can only happen if spans aren't
	219	// returned in strict y/x order, or the first time through.
	220	if (lwmloy > spanloy) {
	221	lwm.copyStateFrom(resetState);
	222	lwm.nextYRange(rgnbox);
	223	lwmloy = rgnbox[1];
	224	lwmhiy = rgnbox[3];
	225	}
	226	// Skip to the first rgn row whose bottom edge is
	227	// below the top of the current span. This will only
	228	// execute >0 times when the current span starts in a
	229	// lower region row than the previous one, or possibly the
	230	// first time through.
	231	while (lwmhiy <= spanloy) {
	232	if (!lwm.nextYRange(rgnbox))
	233	break;
	234	lwmloy = rgnbox[1];
	235	lwmhiy = rgnbox[3];
	236	}
	237	// If the row overlaps the span, process it, otherwise
	238	// fetch another span
	239	if (lwmhiy > spanloy && lwmloy < spanhiy) {
	240	// Update the current row if it's different from the
	241	// new lwm
	242	if (rgnloy != lwmloy) {
	243	row.copyStateFrom(lwm);
	244	rgnloy = lwmloy;
	245	rgnhiy = lwmhiy;
	246	}
	247	box.copyStateFrom(row);
	248	doNextBox = true;
	249	doNextSpan = false;
	250	}
	251	continue;
	252	}
	253
	254	// The current row's spans are exhausted, do the next one
	255	if (doNextRow) {
	256	// Next time we either do the next span or the next box
	257	doNextRow = false;
	258	// Get the next row
	259	boolean ok = row.nextYRange(rgnbox);
	260	// If there was one, update the bounds
	261	if (ok) {
	262	rgnloy = rgnbox[1];
	263	rgnhiy = rgnbox[3];
	264	}
	265	if (!ok \|\| rgnloy >= spanhiy) {
	266	// If we've exhausted the rows or this one is below the span,
	267	// go onto the next span
	268	doNextSpan = true;
	269	}
	270	else {
	271	// Otherwise get the first box on this row
	272	box.copyStateFrom(row);
	273	doNextBox = true;
	274	}
	275	continue;
	276	}
	277
	278	// Process the next box in the current row
	279	if (doNextBox) {
	280	boolean ok = box.nextXBand(rgnbox);
	281	if (ok) {
	282	rgnlox = rgnbox[0];
	283	rgnhix = rgnbox[2];
	284	}
	285	if (!ok \|\| rgnlox >= spanhix) {
	286	// If there was no next rgn span or it's beyond the
	287	// source span, go onto the next row or span
	288	doNextBox = false;
	289	if (rgnhiy >= spanhiy) {
	290	// If the current row totally overlaps the span,
	291	// go onto the next span
	292	doNextSpan = true;
	293	} else {
	294	// otherwise go onto the next rgn row
	295	doNextRow = true;
	296	}
	297	} else {
	298	// Otherwise, if the new rgn span overlaps the
	299	// spanbox, no need to get another box
	300	doNextBox = rgnhix <= spanlox;
	301	}
	302	continue;
	303	}
	304
	305	// Prepare to do the next box either on this call or
	306	// or the subsequent one
	307	doNextBox = true;
	308
	309	// Clip the current span against the current box
	310	if (spanlox > rgnlox) {
	311	resultlox = spanlox;
	312	}
	313	else {
	314	resultlox = rgnlox;
	315	}
	316
	317	if (spanloy > rgnloy) {
	318	resultloy = spanloy;
	319	}
	320	else {
	321	resultloy = rgnloy;
	322	}
	323
	324	if (spanhix < rgnhix) {
	325	resulthix = spanhix;
	326	}
	327	else {
	328	resulthix = rgnhix;
	329	}
	330
	331	if (spanhiy < rgnhiy) {
	332	resulthiy = spanhiy;
	333	}
	334	else {
	335	resulthiy = rgnhiy;
	336	}
	337
	338	// If the result is empty, try then next box
	339	// otherwise return the box.
	340	// REMIND: I think by definition it's non-empty
	341	// if we're here. Need to think about this some more.
	342	if (resultlox >= resulthix \|\|
	343	resultloy >= resulthiy) {
	344	continue;
	345	}
	346	else {
	347	break;
	348	}
	349	}
	350
	351	resultbox[0] = resultlox;
	352	resultbox[1] = resultloy;
	353	resultbox[2] = resulthix;
	354	resultbox[3] = resulthiy;
	355	return true;
	356
	357	}
	358
	359
	360	/**
	361	* This method tells the iterator that it may skip all spans
	362	* whose Y range is completely above the indicated Y coordinate.
	363	*/
	364	public void skipDownTo(int y) {
	365	spanIter.skipDownTo(y);
	366	}
	367
	368	/**
	369	* This method returns a native pointer to a function block that
	370	* can be used by a native method to perform the same iteration
	371	* cycle that the above methods provide while avoiding upcalls to
	372	* the Java object.
	373	* The definition of the structure whose pointer is returned by
	374	* this method is defined in:
	375	* <pre>
	376	* src/share/native/sun/java2d/pipe/SpanIterator.h
	377	* </pre>
	378	*/
	379	public long getNativeIterator() {
	380	return 0;
	381	}
	382
	383	/*
	384	* Cleans out all internal data structures.
	385	*/
	386	//public native void dispose();
	387
	388	protected void finalize() {
	389	//dispose();
	390	}
	391
	392	}

java/pkg/sun/java2d/pipe/RegionIterator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RegionIterator.java+101−0

@@ -0,0 +1,101 @@
	1	/*
	2	* Copyright (c) 1998, 2002, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29
	30	/**
	31	* This class defines the API for iterating through the bands
	32	* of a region object.
	33	*/
	34	public class RegionIterator {
	35	Region region;
	36	int curIndex;
	37	int numXbands;
	38
	39	RegionIterator(Region r) {
	40	region = r;
	41	}
	42
	43	/**
	44	* Returns a new RegionIterator object representing the same
	45	* iteration state as this object to allow multiple iteration
	46	* branches from the current position.
	47	*/
	48	public RegionIterator createCopy() {
	49	RegionIterator r = new RegionIterator(region);
	50	r.curIndex = this.curIndex;
	51	r.numXbands = this.numXbands;
	52	return r;
	53	}
	54
	55	/**
	56	* Copies the iteration state from this RegionIterator object
	57	* into another RegionIterator object to allow multiple iteration
	58	* branches from the current position.
	59	*/
	60	public void copyStateFrom(RegionIterator ri) {
	61	if (this.region != ri.region) {
	62	throw new InternalError("region mismatch");
	63	}
	64	this.curIndex = ri.curIndex;
	65	this.numXbands = ri.numXbands;
	66	}
	67
	68	/**
	69	* Moves the iteration state to the beginning of the next
	70	* Y range in the region returning true if one is found
	71	* and recording the low and high Y coordinates of the
	72	* range in the array at locations 1 and 3 respectively.
	73	*/
	74	public boolean nextYRange(int range[]) {
	75	curIndex += numXbands * 2;
	76	numXbands = 0;
	77	if (curIndex >= region.endIndex) {
	78	return false;
	79	}
	80	range[1] = region.bands[curIndex++];
	81	range[3] = region.bands[curIndex++];
	82	numXbands = region.bands[curIndex++];
	83	return true;
	84	}
	85
	86	/**
	87	* Moves the iteration state to the beginning of the next
	88	* X band in the current Y range returning true if one is
	89	* found and recording the low and high X coordinates of
	90	* the range in the array at locations 0 and 2 respectively.
	91	*/
	92	public boolean nextXBand(int range[]) {
	93	if (numXbands <= 0) {
	94	return false;
	95	}
	96	numXbands--;
	97	range[0] = region.bands[curIndex++];
	98	range[2] = region.bands[curIndex++];
	99	return true;
	100	}
	101	}

java/pkg/sun/java2d/pipe/RegionSpanIterator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RegionSpanIterator.java+210−0

@@ -0,0 +1,210 @@
	1	/*
	2	* Copyright (c) 1999, 2002, 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.java2d.pipe;
	27
	28	/**
	29	* This class implements the ShapeIterator interface for a Region.
	30	* This is useful as the source iterator of a device clip region
	31	* (in its native guise), and also as the result of clipping a
	32	* Region to a rectangle.
	33	*/
	34	public class RegionSpanIterator implements SpanIterator {
	35	// The RegionIterator that we use to do the work
	36	RegionIterator ri;
	37
	38	// Clipping bounds
	39	int lox, loy, hix, hiy;
	40
	41	// Current Y band limits
	42	int curloy, curhiy;
	43
	44	// Are we done?
	45	boolean done = false;
	46
	47	// Is the associated Region rectangular?
	48	boolean isrect;
	49
	50	/*
	51	REMIND: For native implementation
	52	long pData; // Private storage of rect info
	53
	54	static {
	55	initIDs();
	56	}
	57
	58	public static native void initIDs();
	59	*/
	60
	61	/**
	62	* Constructs an instance based on the given Region
	63	*/
	64	public RegionSpanIterator(Region r) {
	65	int[] bounds = new int[4];
	66
	67	r.getBounds(bounds);
	68	lox = bounds[0];
	69	loy = bounds[1];
	70	hix = bounds[2];
	71	hiy = bounds[3];
	72	isrect = r.isRectangular();
	73
	74	ri = r.getIterator();
	75	}
	76
	77	/**
	78	* Gets the bbox of the available region spans.
	79	*/
	80	public void getPathBox(int pathbox[]) {
	81	pathbox[0] = lox;
	82	pathbox[1] = loy;
	83	pathbox[2] = hix;
	84	pathbox[3] = hiy;
	85	}
	86
	87	/**
	88	* Intersect the box used for clipping the output spans with the
	89	* given box.
	90	*/
	91	public void intersectClipBox(int clox, int cloy, int chix, int chiy) {
	92	if (clox > lox) {
	93	lox = clox;
	94	}
	95	if (cloy > loy) {
	96	loy = cloy;
	97	}
	98	if (chix < hix) {
	99	hix = chix;
	100	}
	101	if (chiy < hiy) {
	102	hiy = chiy;
	103	}
	104	done = lox >= hix \|\| loy >= hiy;
	105	}
	106
	107	/**
	108	* Fetches the next span that needs to be operated on.
	109	* If the return value is false then there are no more spans.
	110	*/
	111	public boolean nextSpan(int spanbox[]) {
	112
	113	// Quick test for end conditions
	114	if (done) {
	115	return false;
	116	}
	117
	118	// If the Region is rectangular, we store our bounds (possibly
	119	// clipped via intersectClipBox()) in spanbox and return true
	120	// so that the caller will process the single span. We set done
	121	// to true to ensure that this will be the last span processed.
	122	if (isrect) {
	123	getPathBox(spanbox);
	124	done = true;
	125	return true;
	126	}
	127
	128	// Local cache of current span's bounds
	129	int curlox, curhix;
	130	int curloy = this.curloy;
	131	int curhiy = this.curhiy;
	132
	133	while (true) {
	134	if (!ri.nextXBand(spanbox)) {
	135	if (!ri.nextYRange(spanbox)) {
	136	done = true;
	137	return false;
	138	}
	139	// Update the current y band and clip it
	140	curloy = spanbox[1];
	141	curhiy = spanbox[3];
	142	if (curloy < loy) {
	143	curloy = loy;
	144	}
	145	if (curhiy > hiy) {
	146	curhiy = hiy;
	147	}
	148	// Check for moving below the clip rect
	149	if (curloy >= hiy) {
	150	done = true;
	151	return false;
	152	}
	153	continue;
	154	}
	155	// Clip the x box
	156	curlox = spanbox[0];
	157	curhix = spanbox[2];
	158	if (curlox < lox) {
	159	curlox = lox;
	160	}
	161	if (curhix > hix) {
	162	curhix = hix;
	163	}
	164	// If it's non- box, we're done
	165	if (curlox < curhix && curloy < curhiy) {
	166	break;
	167	}
	168	}
	169
	170	// Update the result and the store y range
	171	spanbox[0] = curlox;
	172	spanbox[1] = this.curloy = curloy;
	173	spanbox[2] = curhix;
	174	spanbox[3] = this.curhiy = curhiy;
	175	return true;
	176	}
	177
	178	/**
	179	* This method tells the iterator that it may skip all spans
	180	* whose Y range is completely above the indicated Y coordinate.
	181	*/
	182	public void skipDownTo(int y) {
	183	loy = y;
	184	}
	185
	186	/**
	187	* This method returns a native pointer to a function block that
	188	* can be used by a native method to perform the same iteration
	189	* cycle that the above methods provide while avoiding upcalls to
	190	* the Java object.
	191	* The definition of the structure whose pointer is returned by
	192	* this method is defined in:
	193	* <pre>
	194	* src/share/native/sun/java2d/pipe/SpanIterator.h
	195	* </pre>
	196	*/
	197	public long getNativeIterator() {
	198	return 0;
	199	}
	200
	201	/*
	202	* Cleans out all internal data structures.
	203	* REMIND: Native implementation
	204	public native void dispose();
	205
	206	protected void finalize() {
	207	dispose();
	208	}
	209	*/
	210	}

java/pkg/sun/java2d/pipe/RenderBuffer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RenderBuffer.java+294−0

@@ -0,0 +1,294 @@
	1	/*
	2	* Copyright (c) 2005, 2010, 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.java2d.pipe;
	27
	28	import sun.misc.Unsafe;
	29
	30	/**
	31	* The RenderBuffer class is a simplified, high-performance, Unsafe wrapper
	32	* used for buffering rendering operations in a single-threaded rendering
	33	* environment. It's functionality is similar to the ByteBuffer and related
	34	* NIO classes. However, the methods in this class perform little to no
	35	* alignment or bounds checks for performance reasons. Therefore, it is
	36	* the caller's responsibility to ensure that all put() calls are properly
	37	* aligned and within bounds:
	38	* - int and float values must be aligned on 4-byte boundaries
	39	* - long and double values must be aligned on 8-byte boundaries
	40	*
	41	* This class only includes the bare minimum of methods to support
	42	* single-threaded rendering. For example, there is no put(double[]) method
	43	* because we currently have no need for such a method in the STR classes.
	44	*/
	45	public class RenderBuffer {
	46
	47	/**
	48	* These constants represent the size of various data types (in bytes).
	49	*/
	50	protected static final long SIZEOF_BYTE = 1L;
	51	protected static final long SIZEOF_SHORT = 2L;
	52	protected static final long SIZEOF_INT = 4L;
	53	protected static final long SIZEOF_FLOAT = 4L;
	54	protected static final long SIZEOF_LONG = 8L;
	55	protected static final long SIZEOF_DOUBLE = 8L;
	56
	57	/**
	58	* Represents the number of elements at which we have empirically
	59	* determined that the average cost of a JNI call exceeds the expense
	60	* of an element by element copy. In other words, if the number of
	61	* elements in an array to be copied exceeds this value, then we should
	62	* use the copyFromArray() method to complete the bulk put operation.
	63	* (This value can be adjusted if the cost of JNI downcalls is reduced
	64	* in a future release.)
	65	*/
	66	private static final int COPY_FROM_ARRAY_THRESHOLD = 6;
	67
	68	protected final Unsafe unsafe;
	69	protected final long baseAddress;
	70	protected final long endAddress;
	71	protected long curAddress;
	72	protected final int capacity;
	73
	74	protected RenderBuffer(int numBytes) {
	75	unsafe = Unsafe.getUnsafe();
	76	curAddress = baseAddress = unsafe.allocateMemory(numBytes);
	77	endAddress = baseAddress + numBytes;
	78	capacity = numBytes;
	79	}
	80
	81	/**
	82	* Allocates a fresh buffer using the machine endianness.
	83	*/
	84	public static RenderBuffer allocate(int numBytes) {
	85	return new RenderBuffer(numBytes);
	86	}
	87
	88	/**
	89	* Returns the base address of the underlying memory buffer.
	90	*/
	91	public final long getAddress() {
	92	return baseAddress;
	93	}
	94
	95	/**
	96	* The behavior (and names) of the following methods are nearly
	97	* identical to their counterparts in the various NIO Buffer classes.
	98	*/
	99
	100	public final int capacity() {
	101	return capacity;
	102	}
	103
	104	public final int remaining() {
	105	return (int)(endAddress - curAddress);
	106	}
	107
	108	public final int position() {
	109	return (int)(curAddress - baseAddress);
	110	}
	111
	112	public final void position(long numBytes) {
	113	curAddress = baseAddress + numBytes;
	114	}
	115
	116	public final void clear() {
	117	curAddress = baseAddress;
	118	}
	119
	120	public final RenderBuffer skip(long numBytes) {
	121	curAddress += numBytes;
	122	return this;
	123	}
	124
	125	/**
	126	* putByte() methods...
	127	*/
	128
	129	public final RenderBuffer putByte(byte x) {
	130	unsafe.putByte(curAddress, x);
	131	curAddress += SIZEOF_BYTE;
	132	return this;
	133	}
	134
	135	public RenderBuffer put(byte[] x) {
	136	return put(x, 0, x.length);
	137	}
	138
	139	public RenderBuffer put(byte[] x, int offset, int length) {
	140	if (length > COPY_FROM_ARRAY_THRESHOLD) {
	141	long offsetInBytes = offset * SIZEOF_BYTE + Unsafe.ARRAY_BYTE_BASE_OFFSET;
	142	long lengthInBytes = length * SIZEOF_BYTE;
	143	unsafe.copyMemory(x, offsetInBytes, null, curAddress, lengthInBytes);
	144	position(position() + lengthInBytes);
	145	} else {
	146	int end = offset + length;
	147	for (int i = offset; i < end; i++) {
	148	putByte(x[i]);
	149	}
	150	}
	151	return this;
	152	}
	153
	154	/**
	155	* putShort() methods...
	156	*/
	157
	158	public final RenderBuffer putShort(short x) {
	159	// assert (position() % SIZEOF_SHORT == 0);
	160	unsafe.putShort(curAddress, x);
	161	curAddress += SIZEOF_SHORT;
	162	return this;
	163	}
	164
	165	public RenderBuffer put(short[] x) {
	166	return put(x, 0, x.length);
	167	}
	168
	169	public RenderBuffer put(short[] x, int offset, int length) {
	170	// assert (position() % SIZEOF_SHORT == 0);
	171	if (length > COPY_FROM_ARRAY_THRESHOLD) {
	172	long offsetInBytes = offset * SIZEOF_SHORT + Unsafe.ARRAY_SHORT_BASE_OFFSET;
	173	long lengthInBytes = length * SIZEOF_SHORT;
	174	unsafe.copyMemory(x, offsetInBytes, null, curAddress, lengthInBytes);
	175	position(position() + lengthInBytes);
	176	} else {
	177	int end = offset + length;
	178	for (int i = offset; i < end; i++) {
	179	putShort(x[i]);
	180	}
	181	}
	182	return this;
	183	}
	184
	185	/**
	186	* putInt() methods...
	187	*/
	188
	189	public final RenderBuffer putInt(int pos, int x) {
	190	// assert (baseAddress + pos % SIZEOF_INT == 0);
	191	unsafe.putInt(baseAddress + pos, x);
	192	return this;
	193	}
	194
	195	public final RenderBuffer putInt(int x) {
	196	// assert (position() % SIZEOF_INT == 0);
	197	unsafe.putInt(curAddress, x);
	198	curAddress += SIZEOF_INT;
	199	return this;
	200	}
	201
	202	public RenderBuffer put(int[] x) {
	203	return put(x, 0, x.length);
	204	}
	205
	206	public RenderBuffer put(int[] x, int offset, int length) {
	207	// assert (position() % SIZEOF_INT == 0);
	208	if (length > COPY_FROM_ARRAY_THRESHOLD) {
	209	long offsetInBytes = offset * SIZEOF_INT + Unsafe.ARRAY_INT_BASE_OFFSET;
	210	long lengthInBytes = length * SIZEOF_INT;
	211	unsafe.copyMemory(x, offsetInBytes, null, curAddress, lengthInBytes);
	212	position(position() + lengthInBytes);
	213	} else {
	214	int end = offset + length;
	215	for (int i = offset; i < end; i++) {
	216	putInt(x[i]);
	217	}
	218	}
	219	return this;
	220	}
	221
	222	/**
	223	* putFloat() methods...
	224	*/
	225
	226	public final RenderBuffer putFloat(float x) {
	227	// assert (position() % SIZEOF_FLOAT == 0);
	228	unsafe.putFloat(curAddress, x);
	229	curAddress += SIZEOF_FLOAT;
	230	return this;
	231	}
	232
	233	public RenderBuffer put(float[] x) {
	234	return put(x, 0, x.length);
	235	}
	236
	237	public RenderBuffer put(float[] x, int offset, int length) {
	238	// assert (position() % SIZEOF_FLOAT == 0);
	239	if (length > COPY_FROM_ARRAY_THRESHOLD) {
	240	long offsetInBytes = offset * SIZEOF_FLOAT + Unsafe.ARRAY_FLOAT_BASE_OFFSET;
	241	long lengthInBytes = length * SIZEOF_FLOAT;
	242	unsafe.copyMemory(x, offsetInBytes, null, curAddress, lengthInBytes);
	243	position(position() + lengthInBytes);
	244	} else {
	245	int end = offset + length;
	246	for (int i = offset; i < end; i++) {
	247	putFloat(x[i]);
	248	}
	249	}
	250	return this;
	251	}
	252
	253	/**
	254	* putLong() methods...
	255	*/
	256
	257	public final RenderBuffer putLong(long x) {
	258	// assert (position() % SIZEOF_LONG == 0);
	259	unsafe.putLong(curAddress, x);
	260	curAddress += SIZEOF_LONG;
	261	return this;
	262	}
	263
	264	public RenderBuffer put(long[] x) {
	265	return put(x, 0, x.length);
	266	}
	267
	268	public RenderBuffer put(long[] x, int offset, int length) {
	269	// assert (position() % SIZEOF_LONG == 0);
	270	if (length > COPY_FROM_ARRAY_THRESHOLD) {
	271	long offsetInBytes = offset * SIZEOF_LONG + Unsafe.ARRAY_LONG_BASE_OFFSET;
	272	long lengthInBytes = length * SIZEOF_LONG;
	273	unsafe.copyMemory(x, offsetInBytes, null, curAddress, lengthInBytes);
	274	position(position() + lengthInBytes);
	275	} else {
	276	int end = offset + length;
	277	for (int i = offset; i < end; i++) {
	278	putLong(x[i]);
	279	}
	280	}
	281	return this;
	282	}
	283
	284	/**
	285	* putDouble() method(s)...
	286	*/
	287
	288	public final RenderBuffer putDouble(double x) {
	289	// assert (position() % SIZEOF_DOUBLE == 0);
	290	unsafe.putDouble(curAddress, x);
	291	curAddress += SIZEOF_DOUBLE;
	292	return this;
	293	}
	294	}

java/pkg/sun/java2d/pipe/RenderQueue.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RenderQueue.java+223−0

@@ -0,0 +1,223 @@
	1	/*
	2	* Copyright (c) 2005, 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.java2d.pipe;
	27
	28	import java.util.HashSet;
	29	import java.util.Set;
	30	import sun.awt.SunToolkit;
	31
	32	/**
	33	* The RenderQueue class encapsulates a RenderBuffer on which rendering
	34	* operations are enqueued. Note that the RenderQueue lock must be acquired
	35	* before performing any operations on the queue (e.g. enqueuing an operation
	36	* or flushing the queue). A sample usage scenario follows:
	37	*
	38	* public void drawSomething(...) {
	39	* rq.lock();
	40	* try {
	41	* ctx.validate(...);
	42	* rq.ensureCapacity(4);
	43	* rq.getBuffer().putInt(DRAW_SOMETHING);
	44	* ...
	45	* } finally {
	46	* rq.unlock();
	47	* }
	48	* }
	49	*
	50	* If you are enqueuing an operation that involves 8-byte parameters (i.e.
	51	* long or double values), it is imperative that you ensure proper
	52	* alignment of the underlying RenderBuffer. This can be accomplished
	53	* simply by providing an offset to the first 8-byte parameter in your
	54	* operation to the ensureCapacityAndAlignment() method. For example:
	55	*
	56	* public void drawStuff(...) {
	57	* rq.lock();
	58	* try {
	59	* RenderBuffer buf = rq.getBuffer();
	60	* ctx.validate(...);
	61	* // 28 total bytes in the operation, 12 bytes to the first long
	62	* rq.ensureCapacityAndAlignment(28, 12);
	63	* buf.putInt(DRAW_STUFF);
	64	* buf.putInt(x).putInt(y);
	65	* buf.putLong(addr1);
	66	* buf.putLong(addr2);
	67	* } finally {
	68	* rq.unlock();
	69	* }
	70	* }
	71	*/
	72	public abstract class RenderQueue {
	73
	74	/** The size of the underlying buffer, in bytes. */
	75	private static final int BUFFER_SIZE = 32000;
	76
	77	/** The underlying buffer for this queue. */
	78	protected RenderBuffer buf;
	79
	80	/**
	81	* A Set containing hard references to Objects that must stay alive until
	82	* the queue has been completely flushed.
	83	*/
	84	protected Set refSet;
	85
	86	protected RenderQueue() {
	87	refSet = new HashSet();
	88	buf = RenderBuffer.allocate(BUFFER_SIZE);
	89	}
	90
	91	/**
	92	* Locks the queue for read/write access.
	93	*/
	94	public final void lock() {
	95	/*
	96	* Implementation note: In theory we should have two separate locks:
	97	* one lock to synchronize access to the RenderQueue, and then a
	98	* separate lock (the AWT lock) that only needs to be acquired when
	99	* we are about to flush the queue (using native windowing system
	100	* operations). In practice it has been difficult to enforce the
	101	* correct lock ordering; sometimes AWT will have already acquired
	102	* the AWT lock before grabbing the RQ lock (see 6253009), while the
	103	* expected order should be RQ lock and then AWT lock. Due to this
	104	* issue, using two separate locks is prone to deadlocks. Therefore,
	105	* to solve this issue we have decided to eliminate the separate RQ
	106	* lock and instead just acquire the AWT lock here. (Someday it might
	107	* be nice to go back to the old two-lock system, but that would
	108	* require potentially risky changes to AWT to ensure that it never
	109	* acquires the AWT lock before calling into 2D code that wants to
	110	* acquire the RQ lock.)
	111	*/
	112	SunToolkit.awtLock();
	113	}
	114
	115	/**
	116	* Attempts to lock the queue. If successful, this method returns true,
	117	* indicating that the caller is responsible for calling
	118	* <code>unlock</code>; otherwise this method returns false.
	119	*/
	120	public final boolean tryLock() {
	121	return SunToolkit.awtTryLock();
	122	}
	123
	124	/**
	125	* Unlocks the queue.
	126	*/
	127	public final void unlock() {
	128	SunToolkit.awtUnlock();
	129	}
	130
	131	/**
	132	* Adds the given Object to the set of hard references, which will
	133	* prevent that Object from being disposed until the queue has been
	134	* flushed completely. This is useful in cases where some enqueued
	135	* data could become invalid if the reference Object were garbage
	136	* collected before the queue could be processed. (For example, keeping
	137	* a hard reference to a FontStrike will prevent any enqueued glyph
	138	* images associated with that strike from becoming invalid before the
	139	* queue is flushed.) The reference set will be cleared immediately
	140	* after the queue is flushed each time.
	141	*/
	142	public final void addReference(Object ref) {
	143	refSet.add(ref);
	144	}
	145
	146	/**
	147	* Returns the encapsulated RenderBuffer object.
	148	*/
	149	public final RenderBuffer getBuffer() {
	150	return buf;
	151	}
	152
	153	/**
	154	* Ensures that there will be enough room on the underlying buffer
	155	* for the following operation. If the operation will not fit given
	156	* the remaining space, the buffer will be flushed immediately, leaving
	157	* an empty buffer for the impending operation.
	158	*
	159	* @param opsize size (in bytes) of the following operation
	160	*/
	161	public final void ensureCapacity(int opsize) {
	162	if (buf.remaining() < opsize) {
	163	flushNow();
	164	}
	165	}
	166
	167	/**
	168	* Convenience method that is equivalent to calling ensureCapacity()
	169	* followed by ensureAlignment(). The ensureCapacity() call allows for an
	170	* extra 4 bytes of space in case the ensureAlignment() method needs to
	171	* insert a NOOP token on the buffer.
	172	*
	173	* @param opsize size (in bytes) of the following operation
	174	* @param first8ByteValueOffset offset (in bytes) from the current
	175	* position to the first 8-byte value used in the following operation
	176	*/
	177	public final void ensureCapacityAndAlignment(int opsize,
	178	int first8ByteValueOffset)
	179	{
	180	ensureCapacity(opsize + 4);
	181	ensureAlignment(first8ByteValueOffset);
	182	}
	183
	184	/**
	185	* Inserts a 4-byte NOOP token when necessary to ensure that all 8-byte
	186	* parameters for the following operation are added to the underlying
	187	* buffer with an 8-byte memory alignment.
	188	*
	189	* @param first8ByteValueOffset offset (in bytes) from the current
	190	* position to the first 8-byte value used in the following operation
	191	*/
	192	public final void ensureAlignment(int first8ByteValueOffset) {
	193	int first8ByteValuePosition = buf.position() + first8ByteValueOffset;
	194	if ((first8ByteValuePosition & 7) != 0) {
	195	buf.putInt(BufferedOpCodes.NOOP);
	196	}
	197	}
	198
	199	/**
	200	* Immediately processes each operation currently pending on the buffer.
	201	* This method will block until the entire buffer has been flushed. The
	202	* queue lock must be acquired before calling this method.
	203	*/
	204	public abstract void flushNow();
	205
	206	/**
	207	* Immediately processes each operation currently pending on the buffer,
	208	* and then invokes the provided task. This method will block until the
	209	* entire buffer has been flushed and the provided task has been executed.
	210	* The queue lock must be acquired before calling this method.
	211	*/
	212	public abstract void flushAndInvokeNow(Runnable task);
	213
	214	/**
	215	* Updates the current position of the underlying buffer, and then
	216	* flushes the queue immediately. This method is useful when native code
	217	* has added data to the queue and needs to flush immediately.
	218	*/
	219	public void flushNow(int position) {
	220	buf.position(position);
	221	flushNow();
	222	}
	223	}

java/pkg/sun/java2d/pipe/RenderingEngine$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RenderingEngine$Tracer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RenderingEngine.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/RenderingEngine.java+482−0

@@ -0,0 +1,482 @@
	1	/*
	2	* Copyright (c) 2007, 2010, 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.java2d.pipe;
	27
	28	import java.awt.Shape;
	29	import java.awt.BasicStroke;
	30	import java.awt.geom.PathIterator;
	31	import java.awt.geom.AffineTransform;
	32
	33	import java.security.PrivilegedAction;
	34	import java.security.AccessController;
	35	import java.util.ServiceLoader;
	36	import sun.security.action.GetPropertyAction;
	37
	38	import sun.awt.geom.PathConsumer2D;
	39
	40	/**
	41	* This class abstracts a number of features for which the Java 2D
	42	* implementation relies on proprietary licensed software libraries.
	43	* Access to those features is now achieved by retrieving the singleton
	44	* instance of this class and calling the appropriate methods on it.
	45	* The 3 primary features abstracted here include:
	46	* <dl>
	47	* <dt>Shape createStrokedShape(Shape, [BasicStroke attributes]);
	48	* <dd>This method implements the functionality of the method of the
	49	* same name on the {@link BasicStroke} class.
	50	* <dt>void strokeTo(Shape, [rendering parameters], PathConsumer2D);
	51	* <dd>This method performs widening of the source path on the fly
	52	* and sends the results to the given {@link PathConsumer2D} object.
	53	* This procedure avoids having to create an intermediate Shape
	54	* object to hold the results of the {@code createStrokedShape} method.
	55	* The main user of this method is the Java 2D non-antialiasing renderer.
	56	* <dt>AATileGenerator getAATileGenerator(Shape, [rendering parameters]);
	57	* <dd>This method returns an object which can iterate over the
	58	* specified bounding box and produce tiles of coverage values for
	59	* antialiased rendering. The details of the operation of the
	60	* {@link AATileGenerator} object are explained in its class comments.
	61	* </dl>
	62	* Additionally, the following informational method supplies important
	63	* data about the implementation.
	64	* <dl>
	65	* <dt>float getMinimumAAPenSize()
	66	* <dd>This method provides information on how small the BasicStroke
	67	* line width can get before dropouts occur. Rendering with a BasicStroke
	68	* is defined to never allow the line to have breaks, gaps, or dropouts
	69	* even if the width is set to 0.0f, so this information allows the
	70	* {@link SunGraphics2D} class to detect the "thin line" case and set
	71	* the rendering attributes accordingly.
	72	* </dl>
	73	* At startup the runtime will load a single instance of this class.
	74	* It searches the classpath for a registered provider of this API
	75	* and returns either the last one it finds, or the instance whose
	76	* class name matches the value supplied in the System property
	77	* {@code sun.java2d.renderer}.
	78	* Additionally, a runtime System property flag can be set to trace
	79	* all calls to methods on the {@code RenderingEngine} in use by
	80	* setting the sun.java2d.renderer.trace property to any non-null value.
	81	* <p>
	82	* Parts of the system that need to use any of the above features should
	83	* call {@code RenderingEngine.getInstance()} to obtain the properly
	84	* registered (and possibly trace-enabled) version of the RenderingEngine.
	85	*/
	86	public abstract class RenderingEngine {
	87	private static RenderingEngine reImpl;
	88
	89	/**
	90	* Returns an instance of {@code RenderingEngine} as determined
	91	* by the installation environment and runtime flags.
	92	* <p>
	93	* A specific instance of the {@code RenderingEngine} can be
	94	* chosen by specifying the runtime flag:
	95	* <pre>
	96	* java -Dsun.java2d.renderer=<classname>
	97	* </pre>
	98	*
	99	* If no specific {@code RenderingEngine} is specified on the command
	100	* or Ductus renderer is specified, it will attempt loading the
	101	* sun.dc.DuctusRenderingEngine class using Class.forName as a fastpath;
	102	* if not found, use the ServiceLoader.
	103	* If no specific {@code RenderingEngine} is specified on the command
	104	* line then the last one returned by enumerating all subclasses of
	105	* {@code RenderingEngine} known to the ServiceLoader is used.
	106	* <p>
	107	* Runtime tracing of the actions of the {@code RenderingEngine}
	108	* can be enabled by specifying the runtime flag:
	109	* <pre>
	110	* java -Dsun.java2d.renderer.trace=<any string>
	111	* </pre>
	112	* @return an instance of {@code RenderingEngine}
	113	* @since 1.7
	114	*/
	115	public static synchronized RenderingEngine getInstance() {
	116	if (reImpl != null) {
	117	return reImpl;
	118	}
	119
	120	reImpl = (RenderingEngine)
	121	AccessController.doPrivileged(new PrivilegedAction() {
	122	public Object run() {
	123	final String ductusREClass = "sun.dc.DuctusRenderingEngine";
	124	String reClass =
	125	System.getProperty("sun.java2d.renderer", ductusREClass);
	126	if (reClass.equals(ductusREClass)) {
	127	try {
	128	Class cls = Class.forName(ductusREClass);
	129	return cls.newInstance();
	130	} catch (ClassNotFoundException x) {
	131	// not found
	132	} catch (IllegalAccessException x) {
	133	// should not reach here
	134	} catch (InstantiationException x) {
	135	// should not reach here
	136	}
	137	}
	138
	139	ServiceLoader<RenderingEngine> reLoader =
	140	ServiceLoader.loadInstalled(RenderingEngine.class);
	141
	142	RenderingEngine service = null;
	143
	144	for (RenderingEngine re : reLoader) {
	145	service = re;
	146	if (re.getClass().getName().equals(reClass)) {
	147	break;
	148	}
	149	}
	150	return service;
	151	}
	152	});
	153
	154	if (reImpl == null) {
	155	throw new InternalError("No RenderingEngine module found");
	156	}
	157
	158	GetPropertyAction gpa =
	159	new GetPropertyAction("sun.java2d.renderer.trace");
	160	String reTrace = (String) AccessController.doPrivileged(gpa);
	161	if (reTrace != null) {
	162	reImpl = new Tracer(reImpl);
	163	}
	164
	165	return reImpl;
	166	}
	167
	168	/**
	169	* Create a widened path as specified by the parameters.
	170	* <p>
	171	* The specified {@code src} {@link Shape} is widened according
	172	* to the specified attribute parameters as per the
	173	* {@link BasicStroke} specification.
	174	*
	175	* @param src the source path to be widened
	176	* @param width the width of the widened path as per {@code BasicStroke}
	177	* @param caps the end cap decorations as per {@code BasicStroke}
	178	* @param join the segment join decorations as per {@code BasicStroke}
	179	* @param miterlimit the miter limit as per {@code BasicStroke}
	180	* @param dashes the dash length array as per {@code BasicStroke}
	181	* @param dashphase the initial dash phase as per {@code BasicStroke}
	182	* @return the widened path stored in a new {@code Shape} object
	183	* @since 1.7
	184	*/
	185	public abstract Shape createStrokedShape(Shape src,
	186	float width,
	187	int caps,
	188	int join,
	189	float miterlimit,
	190	float dashes[],
	191	float dashphase);
	192
	193	/**
	194	* Sends the geometry for a widened path as specified by the parameters
	195	* to the specified consumer.
	196	* <p>
	197	* The specified {@code src} {@link Shape} is widened according
	198	* to the parameters specified by the {@link BasicStroke} object.
	199	* Adjustments are made to the path as appropriate for the
	200	* {@link VALUE_STROKE_NORMALIZE} hint if the {@code normalize}
	201	* boolean parameter is true.
	202	* Adjustments are made to the path as appropriate for the
	203	* {@link VALUE_ANTIALIAS_ON} hint if the {@code antialias}
	204	* boolean parameter is true.
	205	* <p>
	206	* The geometry of the widened path is forwarded to the indicated
	207	* {@link PathConsumer2D} object as it is calculated.
	208	*
	209	* @param src the source path to be widened
	210	* @param bs the {@code BasicSroke} object specifying the
	211	* decorations to be applied to the widened path
	212	* @param normalize indicates whether stroke normalization should
	213	* be applied
	214	* @param antialias indicates whether or not adjustments appropriate
	215	* to antialiased rendering should be applied
	216	* @param consumer the {@code PathConsumer2D} instance to forward
	217	* the widened geometry to
	218	* @since 1.7
	219	*/
	220	public abstract void strokeTo(Shape src,
	221	AffineTransform at,
	222	BasicStroke bs,
	223	boolean thin,
	224	boolean normalize,
	225	boolean antialias,
	226	PathConsumer2D consumer);
	227
	228	/**
	229	* Construct an antialiased tile generator for the given shape with
	230	* the given rendering attributes and store the bounds of the tile
	231	* iteration in the bbox parameter.
	232	* The {@code at} parameter specifies a transform that should affect
	233	* both the shape and the {@code BasicStroke} attributes.
	234	* The {@code clip} parameter specifies the current clip in effect
	235	* in device coordinates and can be used to prune the data for the
	236	* operation, but the renderer is not required to perform any
	237	* clipping.
	238	* If the {@code BasicStroke} parameter is null then the shape
	239	* should be filled as is, otherwise the attributes of the
	240	* {@code BasicStroke} should be used to specify a draw operation.
	241	* The {@code thin} parameter indicates whether or not the
	242	* transformed {@code BasicStroke} represents coordinates smaller
	243	* than the minimum resolution of the antialiasing rasterizer as
	244	* specified by the {@code getMinimumAAPenWidth()} method.
	245	* <p>
	246	* Upon returning, this method will fill the {@code bbox} parameter
	247	* with 4 values indicating the bounds of the iteration of the
	248	* tile generator.
	249	* The iteration order of the tiles will be as specified by the
	250	* pseudo-code:
	251	* <pre>
	252	* for (y = bbox[1]; y < bbox[3]; y += tileheight) {
	253	* for (x = bbox[0]; x < bbox[2]; x += tilewidth) {
	254	* }
	255	* }
	256	* </pre>
	257	* If there is no output to be rendered, this method may return
	258	* null.
	259	*
	260	* @param s the shape to be rendered (fill or draw)
	261	* @param at the transform to be applied to the shape and the
	262	* stroke attributes
	263	* @param clip the current clip in effect in device coordinates
	264	* @param bs if non-null, a {@code BasicStroke} whose attributes
	265	* should be applied to this operation
	266	* @param thin true if the transformed stroke attributes are smaller
	267	* than the minimum dropout pen width
	268	* @param normalize true if the {@code VALUE_STROKE_NORMALIZE}
	269	* {@code RenderingHint} is in effect
	270	* @param bbox returns the bounds of the iteration
	271	* @return the {@code AATileGenerator} instance to be consulted
	272	* for tile coverages, or null if there is no output to render
	273	* @since 1.7
	274	*/
	275	public abstract AATileGenerator getAATileGenerator(Shape s,
	276	AffineTransform at,
	277	Region clip,
	278	BasicStroke bs,
	279	boolean thin,
	280	boolean normalize,
	281	int bbox[]);
	282
	283	/**
	284	* Construct an antialiased tile generator for the given parallelogram
	285	* store the bounds of the tile iteration in the bbox parameter.
	286	* The parallelogram is specified as a starting point and 2 delta
	287	* vectors that indicate the slopes of the 2 pairs of sides of the
	288	* parallelogram.
	289	* The 4 corners of the parallelogram are defined by the 4 points:
	290	* <ul>
	291	* <li> {@code x}, {@code y}
	292	* <li> {@code x+dx1}, {@code y+dy1}
	293	* <li> {@code x+dx1+dx2}, {@code y+dy1+dy2}
	294	* <li> {@code x+dx2}, {@code y+dy2}
	295	* </ul>
	296	* The {@code lw1} and {@code lw2} parameters provide a specification
	297	* for an optionally stroked parallelogram if they are positive numbers.
	298	* The {@code lw1} parameter is the ratio of the length of the {@code dx1},
	299	* {@code dx2} delta vector to half of the line width in that same
	300	* direction.
	301	* The {@code lw2} parameter provides the same ratio for the other delta
	302	* vector.
	303	* If {@code lw1} and {@code lw2} are both greater than zero, then
	304	* the parallelogram figure is doubled by both expanding and contracting
	305	* each delta vector by its corresponding {@code lw} value.
	306	* If either (@code lw1) or {@code lw2} are also greater than 1, then
	307	* the inner (contracted) parallelogram disappears and the figure is
	308	* simply a single expanded parallelogram.
	309	* The {@code clip} parameter specifies the current clip in effect
	310	* in device coordinates and can be used to prune the data for the
	311	* operation, but the renderer is not required to perform any
	312	* clipping.
	313	* <p>
	314	* Upon returning, this method will fill the {@code bbox} parameter
	315	* with 4 values indicating the bounds of the iteration of the
	316	* tile generator.
	317	* The iteration order of the tiles will be as specified by the
	318	* pseudo-code:
	319	* <pre>
	320	* for (y = bbox[1]; y < bbox[3]; y += tileheight) {
	321	* for (x = bbox[0]; x < bbox[2]; x += tilewidth) {
	322	* }
	323	* }
	324	* </pre>
	325	* If there is no output to be rendered, this method may return
	326	* null.
	327	*
	328	* @param x the X coordinate of the first corner of the parallelogram
	329	* @param y the Y coordinate of the first corner of the parallelogram
	330	* @param dx1 the X coordinate delta of the first leg of the parallelogram
	331	* @param dy1 the Y coordinate delta of the first leg of the parallelogram
	332	* @param dx2 the X coordinate delta of the second leg of the parallelogram
	333	* @param dy2 the Y coordinate delta of the second leg of the parallelogram
	334	* @param lw1 the line width ratio for the first leg of the parallelogram
	335	* @param lw2 the line width ratio for the second leg of the parallelogram
	336	* @param clip the current clip in effect in device coordinates
	337	* @param bbox returns the bounds of the iteration
	338	* @return the {@code AATileGenerator} instance to be consulted
	339	* for tile coverages, or null if there is no output to render
	340	* @since 1.7
	341	*/
	342	public abstract AATileGenerator getAATileGenerator(double x, double y,
	343	double dx1, double dy1,
	344	double dx2, double dy2,
	345	double lw1, double lw2,
	346	Region clip,
	347	int bbox[]);
	348
	349	/**
	350	* Returns the minimum pen width that the antialiasing rasterizer
	351	* can represent without dropouts occuring.
	352	* @since 1.7
	353	*/
	354	public abstract float getMinimumAAPenSize();
	355
	356	/**
	357	* Utility method to feed a {@link PathConsumer2D} object from a
	358	* given {@link PathIterator}.
	359	* This method deals with the details of running the iterator and
	360	* feeding the consumer a segment at a time.
	361	*/
	362	public static void feedConsumer(PathIterator pi, PathConsumer2D consumer) {
	363	float coords[] = new float[6];
	364	while (!pi.isDone()) {
	365	switch (pi.currentSegment(coords)) {
	366	case PathIterator.SEG_MOVETO:
	367	consumer.moveTo(coords[0], coords[1]);
	368	break;
	369	case PathIterator.SEG_LINETO:
	370	consumer.lineTo(coords[0], coords[1]);
	371	break;
	372	case PathIterator.SEG_QUADTO:
	373	consumer.quadTo(coords[0], coords[1],
	374	coords[2], coords[3]);
	375	break;
	376	case PathIterator.SEG_CUBICTO:
	377	consumer.curveTo(coords[0], coords[1],
	378	coords[2], coords[3],
	379	coords[4], coords[5]);
	380	break;
	381	case PathIterator.SEG_CLOSE:
	382	consumer.closePath();
	383	break;
	384	}
	385	pi.next();
	386	}
	387	}
	388
	389	static class Tracer extends RenderingEngine {
	390	RenderingEngine target;
	391	String name;
	392
	393	public Tracer(RenderingEngine target) {
	394	this.target = target;
	395	name = target.getClass().getName();
	396	}
	397
	398	public Shape createStrokedShape(Shape src,
	399	float width,
	400	int caps,
	401	int join,
	402	float miterlimit,
	403	float dashes[],
	404	float dashphase)
	405	{
	406	System.out.println(name+".createStrokedShape("+
	407	src.getClass().getName()+", "+
	408	"width = "+width+", "+
	409	"caps = "+caps+", "+
	410	"join = "+join+", "+
	411	"miter = "+miterlimit+", "+
	412	"dashes = "+dashes+", "+
	413	"dashphase = "+dashphase+")");
	414	return target.createStrokedShape(src,
	415	width, caps, join, miterlimit,
	416	dashes, dashphase);
	417	}
	418
	419	public void strokeTo(Shape src,
	420	AffineTransform at,
	421	BasicStroke bs,
	422	boolean thin,
	423	boolean normalize,
	424	boolean antialias,
	425	PathConsumer2D consumer)
	426	{
	427	System.out.println(name+".strokeTo("+
	428	src.getClass().getName()+", "+
	429	at+", "+
	430	bs+", "+
	431	(thin ? "thin" : "wide")+", "+
	432	(normalize ? "normalized" : "pure")+", "+
	433	(antialias ? "AA" : "non-AA")+", "+
	434	consumer.getClass().getName()+")");
	435	target.strokeTo(src, at, bs, thin, normalize, antialias, consumer);
	436	}
	437
	438	public float getMinimumAAPenSize() {
	439	System.out.println(name+".getMinimumAAPenSize()");
	440	return target.getMinimumAAPenSize();
	441	}
	442
	443	public AATileGenerator getAATileGenerator(Shape s,
	444	AffineTransform at,
	445	Region clip,
	446	BasicStroke bs,
	447	boolean thin,
	448	boolean normalize,
	449	int bbox[])
	450	{
	451	System.out.println(name+".getAATileGenerator("+
	452	s.getClass().getName()+", "+
	453	at+", "+
	454	clip+", "+
	455	bs+", "+
	456	(thin ? "thin" : "wide")+", "+
	457	(normalize ? "normalized" : "pure")+")");
	458	return target.getAATileGenerator(s, at, clip,
	459	bs, thin, normalize,
	460	bbox);
	461	}
	462	public AATileGenerator getAATileGenerator(double x, double y,
	463	double dx1, double dy1,
	464	double dx2, double dy2,
	465	double lw1, double lw2,
	466	Region clip,
	467	int bbox[])
	468	{
	469	System.out.println(name+".getAATileGenerator("+
	470	x+", "+y+", "+
	471	dx1+", "+dy1+", "+
	472	dx2+", "+dy2+", "+
	473	lw1+", "+lw2+", "+
	474	clip+")");
	475	return target.getAATileGenerator(x, y,
	476	dx1, dy1,
	477	dx2, dy2,
	478	lw1, lw2,
	479	clip, bbox);
	480	}
	481	}
	482	}

java/pkg/sun/java2d/pipe/ShapeDrawPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/ShapeDrawPipe.java+40−0

@@ -0,0 +1,40 @@
	1	/*
	2	* Copyright (c) 1997, 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.java2d.pipe;
	27
	28	import java.awt.Shape;
	29	import sun.java2d.SunGraphics2D;
	30
	31	/**
	32	* This interface defines the set of calls that pipeline objects
	33	* can use to pass on responsibility for drawing generic Shape
	34	* objects.
	35	*/
	36	public interface ShapeDrawPipe {
	37	public void draw(SunGraphics2D sg, Shape s);
	38
	39	public void fill(SunGraphics2D sg, Shape s);
	40	}

java/pkg/sun/java2d/pipe/ShapeSpanIterator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/ShapeSpanIterator.java+201−0

@@ -0,0 +1,201 @@
	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.java2d.pipe;
	27
	28	import java.awt.geom.PathIterator;
	29	import java.awt.Rectangle;
	30	import sun.awt.geom.PathConsumer2D;
	31
	32	/**
	33	* This class can iterate individual span elements generated by scan
	34	* converting a Shape.
	35	* This particular implementation flattens the incoming path and then
	36	* performs simple polygon tracing to calculate the spans.
	37	*
	38	* Note that this class holds pointers to native data which must be
	39	* disposed. It is not marked as finalizable since it is intended
	40	* to be very lightweight and finalization is a comparitively expensive
	41	* procedure. The caller must specifically use try{} finally{} to
	42	* manually ensure that the object is disposed after use, otherwise
	43	* native data structures might be leaked.
	44	*
	45	* Here is a code sample for using this class:
	46	*
	47	* public void fillShape(Shape s, Rectangle clipRect) {
	48	* ShapeSpanIterator ssi = new ShapeSpanIterator(false);
	49	* try {
	50	* ssi.setOutputArea(clipRect);
	51	* ssi.appendPath(s.getPathIterator(null));
	52	* int spanbox[] = new int[4];
	53	* while (ssi.nextSpan(spanbox)) {
	54	* int x = spanbox[0];
	55	* int y = spanbox[1];
	56	* int w = spanbox[2] - x;
	57	* int h = spanbox[3] - y;
	58	* fillRect(x, y, w, h);
	59	* }
	60	* } finally {
	61	* ssi.dispose();
	62	* }
	63	* }
	64	*/
	65	public final class ShapeSpanIterator
	66	implements SpanIterator, PathConsumer2D
	67	{
	68	long pData;
	69
	70	static {
	71	initIDs();
	72	}
	73
	74	public static native void initIDs();
	75
	76	public ShapeSpanIterator(boolean adjust) {
	77	setNormalize(adjust);
	78	}
	79
	80	/*
	81	* Appends the geometry and winding rule from the indicated
	82	* path iterator.
	83	*/
	84	public void appendPath(PathIterator pi) {
	85	float coords[] = new float[6];
	86
	87	setRule(pi.getWindingRule());
	88	while (!pi.isDone()) {
	89	addSegment(pi.currentSegment(coords), coords);
	90	pi.next();
	91	}
	92	pathDone();
	93	}
	94
	95	/*
	96	* Appends the geometry from the indicated set of polygon points.
	97	*/
	98	public native void appendPoly(int xPoints[], int yPoints[], int nPoints,
	99	int xoff, int yoff);
	100
	101	/*
	102	* Sets the normalization flag so that incoming data is
	103	* adjusted to nearest (0.25, 0.25) subpixel position.
	104	*/
	105	private native void setNormalize(boolean adjust);
	106
	107	/*
	108	* Sets the rectangle of interest for storing and returning
	109	* span segments.
	110	*/
	111	public void setOutputAreaXYWH(int x, int y, int w, int h) {
	112	setOutputAreaXYXY(x, y, Region.dimAdd(x, w), Region.dimAdd(y, h));
	113	}
	114
	115	/*
	116	* Sets the rectangle of interest for storing and returning
	117	* span segments.
	118	*/
	119	public native void setOutputAreaXYXY(int lox, int loy, int hix, int hiy);
	120
	121	/*
	122	* Sets the rectangle of interest for storing and returning
	123	* span segments to the specified Rectangle.
	124	*/
	125	public void setOutputArea(Rectangle r) {
	126	setOutputAreaXYWH(r.x, r.y, r.width, r.height);
	127	}
	128
	129	/*
	130	* Sets the rectangle of interest for storing and returning
	131	* span segments to the bounds of the specified Region.
	132	*/
	133	public void setOutputArea(Region r) {
	134	setOutputAreaXYXY(r.lox, r.loy, r.hix, r.hiy);
	135	}
	136
	137	/*
	138	* Sets the winding rule in the native data structures.
	139	*/
	140	public native void setRule(int rule);
	141
	142	/*
	143	* Adds a single PathIterator segment to the internal list of
	144	* path element structures.
	145	*/
	146	public native void addSegment(int type, float coords[]);
	147
	148	/*
	149	* Gets the bbox of the available path segments, clipped to the
	150	* OutputArea.
	151	*/
	152	public native void getPathBox(int pathbox[]);
	153
	154	/*
	155	* Intersects the path box with the given bbox.
	156	* Returned spans are clipped to this region, or discarded
	157	* altogether if they lie outside it.
	158	*/
	159	public native void intersectClipBox(int lox, int loy, int hix, int hiy);
	160
	161	/*
	162	* Fetches the next span that needs to be operated on.
	163	* If the return value is false then there are no more spans.
	164	*/
	165	public native boolean nextSpan(int spanbox[]);
	166
	167	/**
	168	* This method tells the iterator that it may skip all spans
	169	* whose Y range is completely above the indicated Y coordinate.
	170	*/
	171	public native void skipDownTo(int y);
	172
	173	/**
	174	* This method returns a native pointer to a function block that
	175	* can be used by a native method to perform the same iteration
	176	* cycle that the above methods provide while avoiding upcalls to
	177	* the Java object.
	178	* The definition of the structure whose pointer is returned by
	179	* this method is defined in:
	180	* <pre>
	181	* src/share/native/sun/java2d/pipe/SpanIterator.h
	182	* </pre>
	183	*/
	184	public native long getNativeIterator();
	185
	186	/*
	187	* Cleans out all internal data structures.
	188	*/
	189	public native void dispose();
	190
	191	public native void moveTo(float x, float y);
	192	public native void lineTo(float x, float y);
	193	public native void quadTo(float x1, float y1,
	194	float x2, float y2);
	195	public native void curveTo(float x1, float y1,
	196	float x2, float y2,
	197	float x3, float y3);
	198	public native void closePath();
	199	public native void pathDone();
	200	public native long getNativeConsumer();
	201	}

java/pkg/sun/java2d/pipe/SolidTextRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SolidTextRenderer.java+44−0

@@ -0,0 +1,44 @@
	1	/*
	2	* Copyright (c) 2000, 2005, 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.java2d.pipe;
	27
	28	import java.awt.font.GlyphVector;
	29	import sun.awt.SunHints;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.font.GlyphList;
	32
	33	/**
	34	* A delegate pipe of SG2D for drawing text with
	35	* a solid source colour to an opaque destination.
	36	*/
	37
	38	public class SolidTextRenderer extends GlyphListLoopPipe
	39	implements LoopBasedPipe
	40	{
	41	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {
	42	sg2d.loops.drawGlyphListLoop.DrawGlyphList(sg2d, sg2d.surfaceData, gl);
	43	}
	44	}

java/pkg/sun/java2d/pipe/SpanClipRenderer$SCRcontext.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SpanClipRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SpanClipRenderer.java+141−0

@@ -0,0 +1,141 @@
	1	/*
	2	* Copyright (c) 1998, 1999, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.Shape;
	30	import java.awt.geom.PathIterator;
	31	import sun.java2d.SunGraphics2D;
	32
	33	/**
	34	* This class uses a Region iterator to modify the extents of alpha
	35	* tiles created during Shape rendering based upon a non-rectangular
	36	* clipping path.
	37	*/
	38	public class SpanClipRenderer implements CompositePipe
	39	{
	40	CompositePipe outpipe;
	41
	42	static Class RegionClass = Region.class;
	43	static Class RegionIteratorClass = RegionIterator.class;
	44
	45	static {
	46	initIDs(RegionClass, RegionIteratorClass);
	47	}
	48
	49	static native void initIDs(Class rc, Class ric);
	50
	51	public SpanClipRenderer(CompositePipe pipe) {
	52	outpipe = pipe;
	53	}
	54
	55	class SCRcontext {
	56	RegionIterator iterator;
	57	Object outcontext;
	58	int band[];
	59	byte tile[];
	60
	61	public SCRcontext(RegionIterator ri, Object outctx) {
	62	iterator = ri;
	63	outcontext = outctx;
	64	band = new int[4];
	65	}
	66	}
	67
	68	public Object startSequence(SunGraphics2D sg, Shape s, Rectangle devR,
	69	int[] abox) {
	70	RegionIterator ri = sg.clipRegion.getIterator();
	71
	72	return new SCRcontext(ri, outpipe.startSequence(sg, s, devR, abox));
	73	}
	74
	75	public boolean needTile(Object ctx, int x, int y, int w, int h) {
	76	SCRcontext context = (SCRcontext) ctx;
	77	return (outpipe.needTile(context.outcontext, x, y, w, h));
	78	}
	79
	80	public void renderPathTile(Object ctx,
	81	byte[] atile, int offset, int tsize,
	82	int x, int y, int w, int h,
	83	ShapeSpanIterator sr) {
	84	renderPathTile(ctx, atile, offset, tsize, x, y, w, h);
	85	}
	86
	87	public void renderPathTile(Object ctx,
	88	byte[] atile, int offset, int tsize,
	89	int x, int y, int w, int h) {
	90	SCRcontext context = (SCRcontext) ctx;
	91	RegionIterator ri = context.iterator.createCopy();
	92	int[] band = context.band;
	93	band[0] = x;
	94	band[1] = y;
	95	band[2] = x + w;
	96	band[3] = y + h;
	97	if (atile == null) {
	98	int size = w * h;
	99	atile = context.tile;
	100	if (atile != null && atile.length < size) {
	101	atile = null;
	102	}
	103	if (atile == null) {
	104	atile = new byte[size];
	105	context.tile = atile;
	106	}
	107	offset = 0;
	108	tsize = w;
	109	fillTile(ri, atile, offset, tsize, band);
	110	} else {
	111	eraseTile(ri, atile, offset, tsize, band);
	112	}
	113
	114	if (band[2] > band[0] && band[3] > band[1]) {
	115	offset += (band[1] - y) * tsize + (band[0] - x);
	116	outpipe.renderPathTile(context.outcontext,
	117	atile, offset, tsize,
	118	band[0], band[1],
	119	band[2] - band[0],
	120	band[3] - band[1]);
	121	}
	122	}
	123
	124	public native void fillTile(RegionIterator ri,
	125	byte[] alpha, int offset, int tsize,
	126	int[] band);
	127
	128	public native void eraseTile(RegionIterator ri,
	129	byte[] alpha, int offset, int tsize,
	130	int[] band);
	131
	132	public void skipTile(Object ctx, int x, int y) {
	133	SCRcontext context = (SCRcontext) ctx;
	134	outpipe.skipTile(context.outcontext, x, y);
	135	}
	136
	137	public void endSequence(Object ctx) {
	138	SCRcontext context = (SCRcontext) ctx;
	139	outpipe.endSequence(context.outcontext);
	140	}
	141	}

java/pkg/sun/java2d/pipe/SpanIterator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SpanIterator.java+95−0

@@ -0,0 +1,95 @@
	1	/*
	2	* Copyright (c) 1998, 1999, 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.java2d.pipe;
	27
	28	/**
	29	* This interface defines a general method for iterating through the
	30	* rectangular "spans" that represent the interior of a filled path.
	31	* <p>
	32	* There can be many kinds of span iterators used in the rendering
	33	* pipeline, the most basic being an iterator that scan converts a
	34	* path defined by any PathIterator, or an nested iterator which
	35	* intersects another iterator's spans with a clip region.
	36	* Other iterators can be created for scan converting some of the
	37	* primitive shapes more explicitly for speed or quality.
	38	*
	39	* @author Jim Graham
	40	*/
	41	public interface SpanIterator {
	42	/**
	43	* This method returns the bounding box of the spans that the
	44	* iterator will be returning.
	45	* The array must be of length at least 4 and upon return, it
	46	* will be filled with the values:
	47	* <pre>
	48	* {PathMinX, PathMinY, PathMaxX, PathMaxY}.
	49	* </pre>
	50	*/
	51	public void getPathBox(int pathbox[]);
	52
	53	/**
	54	* This method constrains the spans returned by nextSpan() to the
	55	* rectangle whose bounds are given.
	56	*/
	57	public void intersectClipBox(int lox, int loy, int hix, int hiy);
	58
	59	/**
	60	* This method returns the next span in the shape being iterated.
	61	* The array must be of length at least 4 and upon return, it
	62	* will be filled with the values:
	63	* <pre>
	64	* {SpanMinX, SpanMinY, SpanMaxX, SpanMaxY}.
	65	* </pre>
	66	*/
	67	public boolean nextSpan(int spanbox[]);
	68
	69	/**
	70	* This method tells the iterator that it may skip all spans
	71	* whose Y range is completely above the indicated Y coordinate.
	72	* This method is used to provide feedback from the caller when
	73	* clipping prevents the display of any data in a given Y range.
	74	* Typically it will only be called when this iterator has returned
	75	* a span whose MaxY coordinate is less than the indicated Y and
	76	* the calling mechanism wants to avoid unnecessary iteration work.
	77	* While this request could technically be ignored (i.e. a NOP),
	78	* doing so could potentially cause the caller to make this callback
	79	* for each span that is being skipped.
	80	*/
	81	public void skipDownTo(int y);
	82
	83	/**
	84	* This method returns a native pointer to a function block that
	85	* can be used by a native method to perform the same iteration
	86	* cycle that the above methods provide while avoiding upcalls to
	87	* the Java object.
	88	* The definition of the structure whose pointer is returned by
	89	* this method is defined in:
	90	* <pre>
	91	* src/share/native/sun/java2d/pipe/SpanIterator.h
	92	* </pre>
	93	*/
	94	public long getNativeIterator();
	95	}

java/pkg/sun/java2d/pipe/SpanShapeRenderer$Composite.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SpanShapeRenderer$Simple.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SpanShapeRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/SpanShapeRenderer.java+216−0

@@ -0,0 +1,216 @@
	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.java2d.pipe;
	27
	28	import sun.java2d.SunGraphics2D;
	29	import sun.java2d.SurfaceData;
	30	import java.awt.Rectangle;
	31	import java.awt.Shape;
	32	import java.awt.BasicStroke;
	33	import java.awt.geom.PathIterator;
	34	import java.awt.geom.AffineTransform;
	35	import java.awt.geom.Rectangle2D;
	36	import sun.awt.SunHints;
	37
	38	/**
	39	* This class is used to convert raw geometry into a span iterator
	40	* object using a simple flattening polygon scan converter.
	41	* The iterator can be passed on to special SpanFiller loops to
	42	* perform the actual rendering.
	43	*/
	44	public abstract class SpanShapeRenderer implements ShapeDrawPipe {
	45	final static RenderingEngine RenderEngine = RenderingEngine.getInstance();
	46
	47	public static class Composite extends SpanShapeRenderer {
	48	CompositePipe comppipe;
	49
	50	public Composite(CompositePipe pipe) {
	51	comppipe = pipe;
	52	}
	53
	54	public Object startSequence(SunGraphics2D sg, Shape s,
	55	Rectangle devR, int[] bbox) {
	56	return comppipe.startSequence(sg, s, devR, bbox);
	57	}
	58
	59	public void renderBox(Object ctx, int x, int y, int w, int h) {
	60	comppipe.renderPathTile(ctx, null, 0, w, x, y, w, h);
	61	}
	62
	63	public void endSequence(Object ctx) {
	64	comppipe.endSequence(ctx);
	65	}
	66	}
	67
	68	public static class Simple extends SpanShapeRenderer
	69	implements LoopBasedPipe
	70	{
	71	public Object startSequence(SunGraphics2D sg, Shape s,
	72	Rectangle devR, int[] bbox) {
	73	return sg;
	74	}
	75
	76	public void renderBox(Object ctx, int x, int y, int w, int h) {
	77	SunGraphics2D sg2d = (SunGraphics2D) ctx;
	78	SurfaceData sd = sg2d.getSurfaceData();
	79	sg2d.loops.fillRectLoop.FillRect(sg2d, sd, x, y, w, h);
	80	}
	81
	82	public void endSequence(Object ctx) {
	83	}
	84	}
	85
	86	public void draw(SunGraphics2D sg, Shape s) {
	87	if (sg.stroke instanceof BasicStroke) {
	88	ShapeSpanIterator sr = LoopPipe.getStrokeSpans(sg, s);
	89	try {
	90	renderSpans(sg, sg.getCompClip(), s, sr);
	91	} finally {
	92	sr.dispose();
	93	}
	94	} else {
	95	fill(sg, sg.stroke.createStrokedShape(s));
	96	}
	97	}
	98
	99	public static final int NON_RECTILINEAR_TRANSFORM_MASK =
	100	(AffineTransform.TYPE_GENERAL_TRANSFORM \|
	101	AffineTransform.TYPE_GENERAL_ROTATION);
	102
	103	public void fill(SunGraphics2D sg, Shape s) {
	104	if (s instanceof Rectangle2D &&
	105	(sg.transform.getType() & NON_RECTILINEAR_TRANSFORM_MASK) == 0)
	106	{
	107	renderRect(sg, (Rectangle2D) s);
	108	return;
	109	}
	110
	111	Region clipRegion = sg.getCompClip();
	112	ShapeSpanIterator sr = LoopPipe.getFillSSI(sg);
	113	try {
	114	sr.setOutputArea(clipRegion);
	115	sr.appendPath(s.getPathIterator(sg.transform));
	116	renderSpans(sg, clipRegion, s, sr);
	117	} finally {
	118	sr.dispose();
	119	}
	120	}
	121
	122	public abstract Object startSequence(SunGraphics2D sg, Shape s,
	123	Rectangle devR, int[] bbox);
	124
	125	public abstract void renderBox(Object ctx, int x, int y, int w, int h);
	126
	127	public abstract void endSequence(Object ctx);
	128
	129	public void renderRect(SunGraphics2D sg, Rectangle2D r) {
	130	double corners[] = {
	131	r.getX(), r.getY(), r.getWidth(), r.getHeight(),
	132	};
	133	corners[2] += corners[0];
	134	corners[3] += corners[1];
	135	if (corners[2] <= corners[0] \|\| corners[3] <= corners[1]) {
	136	return;
	137	}
	138	sg.transform.transform(corners, 0, corners, 0, 2);
	139	if (corners[2] < corners[0]) {
	140	double t = corners[2];
	141	corners[2] = corners[0];
	142	corners[0] = t;
	143	}
	144	if (corners[3] < corners[1]) {
	145	double t = corners[3];
	146	corners[3] = corners[1];
	147	corners[1] = t;
	148	}
	149	int abox[] = {
	150	(int) corners[0],
	151	(int) corners[1],
	152	(int) corners[2],
	153	(int) corners[3],
	154	};
	155	Rectangle devR = new Rectangle(abox[0], abox[1],
	156	abox[2] - abox[0],
	157	abox[3] - abox[1]);
	158	Region clipRegion = sg.getCompClip();
	159	clipRegion.clipBoxToBounds(abox);
	160	if (abox[0] >= abox[2] \|\| abox[1] >= abox[3]) {
	161	return;
	162	}
	163	Object context = startSequence(sg, r, devR, abox);
	164	if (clipRegion.isRectangular()) {
	165	renderBox(context, abox[0], abox[1],
	166	abox[2] - abox[0],
	167	abox[3] - abox[1]);
	168	} else {
	169	SpanIterator sr = clipRegion.getSpanIterator(abox);
	170	while (sr.nextSpan(abox)) {
	171	renderBox(context, abox[0], abox[1],
	172	abox[2] - abox[0],
	173	abox[3] - abox[1]);
	174	}
	175	}
	176	endSequence(context);
	177	}
	178
	179	public void renderSpans(SunGraphics2D sg, Region clipRegion, Shape s,
	180	ShapeSpanIterator sr)
	181	{
	182	Object context = null;
	183	int abox[] = new int[4];
	184	try {
	185	sr.getPathBox(abox);
	186	Rectangle devR = new Rectangle(abox[0], abox[1],
	187	abox[2] - abox[0],
	188	abox[3] - abox[1]);
	189	clipRegion.clipBoxToBounds(abox);
	190	if (abox[0] >= abox[2] \|\| abox[1] >= abox[3]) {
	191	return;
	192	}
	193	sr.intersectClipBox(abox[0], abox[1], abox[2], abox[3]);
	194	context = startSequence(sg, s, devR, abox);
	195
	196	spanClipLoop(context, sr, clipRegion, abox);
	197
	198	} finally {
	199	if (context != null) {
	200	endSequence(context);
	201	}
	202	}
	203	}
	204
	205	public void spanClipLoop(Object ctx, SpanIterator sr,
	206	Region r, int[] abox) {
	207	if (!r.isRectangular()) {
	208	sr = r.filter(sr);
	209	}
	210	while (sr.nextSpan(abox)) {
	211	int x = abox[0];
	212	int y = abox[1];
	213	renderBox(ctx, x, y, abox[2] - x, abox[3] - y);
	214	}
	215	}
	216	}

java/pkg/sun/java2d/pipe/TextPipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/TextPipe.java+49−0

@@ -0,0 +1,49 @@
	1	/*
	2	* Copyright (c) 1998, 2003, 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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.pipe;
	31
	32	import sun.java2d.SunGraphics2D;
	33	import java.awt.font.GlyphVector;
	34	import java.awt.font.TextLayout;
	35
	36	/**
	37	* This interface defines the set of calls that pipeline objects
	38	* can use to pass on responsibility for drawing various text
	39	* representations.
	40	*/
	41	public interface TextPipe {
	42	public void drawString(SunGraphics2D g2d, String s,
	43	double x, double y);
	44	public void drawGlyphVector(SunGraphics2D g2d, GlyphVector g,
	45	float x, float y);
	46	public void drawChars(SunGraphics2D g2d,
	47	char data[], int offset, int length,
	48	int x, int y);
	49	}

java/pkg/sun/java2d/pipe/TextRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/TextRenderer.java+98−0

@@ -0,0 +1,98 @@
	1	/*
	2	* Copyright (c) 2000, 2003, 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.java2d.pipe;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.Shape;
	30	import java.awt.Font;
	31	import java.awt.font.GlyphVector;
	32	import sun.java2d.SunGraphics2D;
	33	import sun.java2d.loops.FontInfo;
	34	import sun.font.GlyphList;
	35
	36	/*
	37	* This class uses the alpha graybits arrays from a GlyphList object to
	38	* drive a CompositePipe in much the same way as the antialiasing renderer.
	39	*/
	40	public class TextRenderer extends GlyphListPipe {
	41
	42	CompositePipe outpipe;
	43
	44	public TextRenderer(CompositePipe pipe) {
	45	outpipe = pipe;
	46	}
	47
	48	protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {
	49	int num = gl.getNumGlyphs();
	50	Region clipRegion = sg2d.getCompClip();
	51	int cx1 = clipRegion.getLoX();
	52	int cy1 = clipRegion.getLoY();
	53	int cx2 = clipRegion.getHiX();
	54	int cy2 = clipRegion.getHiY();
	55	Object ctx = null;
	56	try {
	57	int[] bounds = gl.getBounds();
	58	Rectangle r = new Rectangle(bounds[0], bounds[1],
	59	bounds[2] - bounds[0],
	60	bounds[3] - bounds[1]);
	61	Shape s = sg2d.untransformShape(r);
	62	ctx = outpipe.startSequence(sg2d, s, r, bounds);
	63	for (int i = 0; i < num; i++) {
	64	gl.setGlyphIndex(i);
	65	int metrics[] = gl.getMetrics();
	66	int gx1 = metrics[0];
	67	int gy1 = metrics[1];
	68	int w = metrics[2];
	69	int gx2 = gx1 + w;
	70	int gy2 = gy1 + metrics[3];
	71	int off = 0;
	72	if (gx1 < cx1) {
	73	off = cx1 - gx1;
	74	gx1 = cx1;
	75	}
	76	if (gy1 < cy1) {
	77	off += (cy1 - gy1) * w;
	78	gy1 = cy1;
	79	}
	80	if (gx2 > cx2) gx2 = cx2;
	81	if (gy2 > cy2) gy2 = cy2;
	82	if (gx2 > gx1 && gy2 > gy1 &&
	83	outpipe.needTile(ctx, gx1, gy1, gx2 - gx1, gy2 - gy1))
	84	{
	85	byte alpha[] = gl.getGrayBits();
	86	outpipe.renderPathTile(ctx, alpha, off, w,
	87	gx1, gy1, gx2 - gx1, gy2 - gy1);
	88	} else {
	89	outpipe.skipTile(ctx, gx1, gy1);
	90	}
	91	}
	92	} finally {
	93	if (ctx != null) {
	94	outpipe.endSequence(ctx);
	95	}
	96	}
	97	}
	98	}

java/pkg/sun/java2d/pipe/ValidatePipe.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/ValidatePipe.java+241−0

@@ -0,0 +1,241 @@
	1	/*
	2	* Copyright (c) 1997, 2003, 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.java2d.pipe;
	27
	28	import java.awt.Color;
	29	import java.awt.Image;
	30	import java.awt.Shape;
	31	import java.awt.geom.AffineTransform;
	32	import java.awt.image.BufferedImage;
	33	import java.awt.image.BufferedImageOp;
	34	import java.awt.image.ImageObserver;
	35	import sun.java2d.SunGraphics2D;
	36	import java.awt.font.GlyphVector;
	37
	38	/**
	39	* This class is used to force a revalidation of the pipelines of
	40	* the indicated SunGraphics2D object before a draw command.
	41	* After calling SunGraphics2D.validatePipe() to force the pipeline
	42	* to be revalidated, this object redispatches the draw command to
	43	* the new valid pipe object.
	44	*/
	45	public class ValidatePipe
	46	implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe, TextPipe,
	47	DrawImagePipe
	48	{
	49	/*
	50	* Different subclasses may override this to do various
	51	* other forms of validation and return a return code
	52	* indicating whether or not the validation was successful.
	53	*/
	54	public boolean validate(SunGraphics2D sg) {
	55	sg.validatePipe();
	56	return true;
	57	}
	58
	59	public void drawLine(SunGraphics2D sg,
	60	int x1, int y1, int x2, int y2) {
	61	if (validate(sg)) {
	62	sg.drawpipe.drawLine(sg, x1, y1, x2, y2);
	63	}
	64	}
	65
	66	public void drawRect(SunGraphics2D sg,
	67	int x, int y, int width, int height) {
	68	if (validate(sg)) {
	69	sg.drawpipe.drawRect(sg, x, y, width, height);
	70	}
	71	}
	72
	73	public void fillRect(SunGraphics2D sg,
	74	int x, int y, int width, int height) {
	75	if (validate(sg)) {
	76	sg.fillpipe.fillRect(sg, x, y, width, height);
	77	}
	78	}
	79
	80	public void drawRoundRect(SunGraphics2D sg,
	81	int x, int y, int width, int height,
	82	int arcWidth, int arcHeight) {
	83	if (validate(sg)) {
	84	sg.drawpipe.drawRoundRect(sg, x, y, width, height,
	85	arcWidth, arcHeight);
	86	}
	87	}
	88
	89	public void fillRoundRect(SunGraphics2D sg,
	90	int x, int y, int width, int height,
	91	int arcWidth, int arcHeight) {
	92	if (validate(sg)) {
	93	sg.fillpipe.fillRoundRect(sg, x, y, width, height,
	94	arcWidth, arcHeight);
	95	}
	96	}
	97
	98	public void drawOval(SunGraphics2D sg,
	99	int x, int y, int width, int height) {
	100	if (validate(sg)) {
	101	sg.drawpipe.drawOval(sg, x, y, width, height);
	102	}
	103	}
	104
	105	public void fillOval(SunGraphics2D sg,
	106	int x, int y, int width, int height) {
	107	if (validate(sg)) {
	108	sg.fillpipe.fillOval(sg, x, y, width, height);
	109	}
	110	}
	111
	112	public void drawArc(SunGraphics2D sg,
	113	int x, int y, int width, int height,
	114	int startAngle, int arcAngle) {
	115	if (validate(sg)) {
	116	sg.drawpipe.drawArc(sg, x, y, width, height, startAngle, arcAngle);
	117	}
	118	}
	119
	120	public void fillArc(SunGraphics2D sg,
	121	int x, int y, int width, int height,
	122	int startAngle, int arcAngle) {
	123	if (validate(sg)) {
	124	sg.fillpipe.fillArc(sg, x, y, width, height, startAngle, arcAngle);
	125	}
	126	}
	127
	128	public void drawPolyline(SunGraphics2D sg,
	129	int xPoints[], int yPoints[],
	130	int nPoints) {
	131	if (validate(sg)) {
	132	sg.drawpipe.drawPolyline(sg, xPoints, yPoints, nPoints);
	133	}
	134	}
	135
	136	public void drawPolygon(SunGraphics2D sg,
	137	int xPoints[], int yPoints[],
	138	int nPoints) {
	139	if (validate(sg)) {
	140	sg.drawpipe.drawPolygon(sg, xPoints, yPoints, nPoints);
	141	}
	142	}
	143
	144	public void fillPolygon(SunGraphics2D sg,
	145	int xPoints[], int yPoints[],
	146	int nPoints) {
	147	if (validate(sg)) {
	148	sg.fillpipe.fillPolygon(sg, xPoints, yPoints, nPoints);
	149	}
	150	}
	151
	152	public void draw(SunGraphics2D sg, Shape s) {
	153	if (validate(sg)) {
	154	sg.shapepipe.draw(sg, s);
	155	}
	156	}
	157
	158	public void fill(SunGraphics2D sg, Shape s) {
	159	if (validate(sg)) {
	160	sg.shapepipe.fill(sg, s);
	161	}
	162	}
	163	public void drawString(SunGraphics2D sg, String s, double x, double y) {
	164	if (validate(sg)) {
	165	sg.textpipe.drawString(sg, s, x, y);
	166	}
	167	}
	168	public void drawGlyphVector(SunGraphics2D sg, GlyphVector g,
	169	float x, float y) {
	170	if (validate(sg)) {
	171	sg.textpipe.drawGlyphVector(sg, g, x, y);
	172	}
	173	}
	174	public void drawChars(SunGraphics2D sg,
	175	char data[], int offset, int length,
	176	int x, int y) {
	177	if (validate(sg)) {
	178	sg.textpipe.drawChars(sg, data, offset, length, x, y);
	179	}
	180	}
	181	public boolean copyImage(SunGraphics2D sg, Image img,
	182	int x, int y,
	183	Color bgColor,
	184	ImageObserver observer) {
	185	if (validate(sg)) {
	186	return sg.imagepipe.copyImage(sg, img, x, y, bgColor, observer);
	187	} else {
	188	return false;
	189	}
	190	}
	191	public boolean copyImage(SunGraphics2D sg, Image img,
	192	int dx, int dy, int sx, int sy, int w, int h,
	193	Color bgColor,
	194	ImageObserver observer) {
	195	if (validate(sg)) {
	196	return sg.imagepipe.copyImage(sg, img, dx, dy, sx, sy, w, h,
	197	bgColor, observer);
	198	} else {
	199	return false;
	200	}
	201	}
	202	public boolean scaleImage(SunGraphics2D sg, Image img, int x, int y,
	203	int w, int h,
	204	Color bgColor,
	205	ImageObserver observer) {
	206	if (validate(sg)) {
	207	return sg.imagepipe.scaleImage(sg, img, x, y, w, h, bgColor,
	208	observer);
	209	} else {
	210	return false;
	211	}
	212	}
	213	public boolean scaleImage(SunGraphics2D sg, Image img,
	214	int dx1, int dy1, int dx2, int dy2,
	215	int sx1, int sy1, int sx2, int sy2,
	216	Color bgColor,
	217	ImageObserver observer) {
	218	if (validate(sg)) {
	219	return sg.imagepipe.scaleImage(sg, img, dx1, dy1, dx2, dy2,
	220	sx1, sy1, sx2, sy2, bgColor,
	221	observer);
	222	} else {
	223	return false;
	224	}
	225	}
	226	public boolean transformImage(SunGraphics2D sg, Image img,
	227	AffineTransform atfm,
	228	ImageObserver observer) {
	229	if (validate(sg)) {
	230	return sg.imagepipe.transformImage(sg, img, atfm, observer);
	231	} else {
	232	return false;
	233	}
	234	}
	235	public void transformImage(SunGraphics2D sg, BufferedImage img,
	236	BufferedImageOp op, int x, int y) {
	237	if (validate(sg)) {
	238	sg.imagepipe.transformImage(sg, img, op, x, y);
	239	}
	240	}
	241	}

java/pkg/sun/java2d/pipe/hw/AccelDeviceEventListener.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/AccelDeviceEventListener.java+59−0

@@ -0,0 +1,59 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	/**
	29	* An interface for receiving notifications about imminent accelerated device's
	30	* events. Upon receiving such event appropriate actions can be taken (for
	31	* example, resources associated with the device can be freed).
	32	*/
	33	public interface AccelDeviceEventListener {
	34	/**
	35	* Called when the device is about to be reset.
	36	*
	37	* One must release all native resources associated with the device which
	38	* prevent the device from being reset (such as Default Pool resources for
	39	* the D3D pipeline).
	40	*
	41	* It is safe to remove the listener while in the call back.
	42	*
	43	* Note: this method is called on the rendering thread,
	44	* do not call into user code, do not take RQ lock!
	45	*/
	46	public void onDeviceReset();
	47
	48	/**
	49	* Called when the device is about to be disposed of.
	50	*
	51	* One must release all native resources associated with the device.
	52	*
	53	* It is safe to remove the listener while in the call back.
	54	*
	55	* Note: this method is called on the rendering thread,
	56	* do not call into user code, do not take RQ lock!
	57	*/
	58	public void onDeviceDispose();
	59	}

java/pkg/sun/java2d/pipe/hw/AccelDeviceEventNotifier.java+167−0

@@ -0,0 +1,167 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	import java.util.Collections;
	29	import java.util.HashMap;
	30	import java.util.Iterator;
	31	import java.util.Map;
	32	import java.util.Set;
	33
	34	/**
	35	* This class is used to notify listeners about accelerated device's
	36	* events such as device reset or dispose that are about to occur.
	37	*/
	38	public class AccelDeviceEventNotifier {
	39
	40	private static AccelDeviceEventNotifier theInstance;
	41
	42	/**
	43	* A device is about to be reset. The listeners have to release all
	44	* resources associated with the device which are required for the device
	45	* to be reset.
	46	*/
	47	public static final int DEVICE_RESET = 0;
	48
	49	/**
	50	* A device is about to be disposed. The listeners have to release all
	51	* resources associated with the device.
	52	*/
	53	public static final int DEVICE_DISPOSED = 1;
	54
	55	private final Map<AccelDeviceEventListener, Integer> listeners;
	56
	57	private AccelDeviceEventNotifier() {
	58	listeners = Collections.synchronizedMap(
	59	new HashMap<AccelDeviceEventListener, Integer>(1));
	60	}
	61
	62	/**
	63	* Returns a singleton of AccelDeviceEventNotifier if it exists. If the
	64	* passed boolean is false and singleton doesn't exist yet, null is
	65	* returned. If the passed boolean is {@code true} and singleton doesn't
	66	* exist it will be created and returned.
	67	*
	68	* @param create whether to create a singleton instance if doesn't yet
	69	* exist
	70	* @return a singleton instance or null
	71	*/
	72	private static synchronized
	73	AccelDeviceEventNotifier getInstance(boolean create)
	74	{
	75	if (theInstance == null && create) {
	76	theInstance = new AccelDeviceEventNotifier();
	77	}
	78	return theInstance;
	79	}
	80
	81	/**
	82	* Called to indicate that a device event had occured.
	83	* If a singleton exists, the listeners (those associated with
	84	* the device) will be notified.
	85	*
	86	* @param screen a screen number of the device which is a source of
	87	* the event
	88	* @param eventType a type of the event
	89	* @see #DEVICE_DISPOSED
	90	* @see #DEVICE_RESET
	91	*/
	92	public static final void eventOccured(int screen, int eventType) {
	93	AccelDeviceEventNotifier notifier = getInstance(false);
	94	if (notifier != null) {
	95	notifier.notifyListeners(eventType, screen);
	96	}
	97	}
	98
	99	/**
	100	* Adds the listener associated with a device on particular screen.
	101	*
	102	* Note: the listener must be removed as otherwise it will forever
	103	* be referenced by the notifier.
	104	*
	105	* @param l the listener
	106	* @param screen the screen number indicating which device the listener is
	107	* interested in.
	108	*/
	109	public static final void addListener(AccelDeviceEventListener l,int screen){
	110	getInstance(true).add(l, screen);
	111	}
	112
	113	/**
	114	* Removes the listener.
	115	*
	116	* @param l the listener
	117	*/
	118	public static final void removeListener(AccelDeviceEventListener l) {
	119	getInstance(true).remove(l);
	120	}
	121
	122	private final void add(AccelDeviceEventListener theListener, int screen) {
	123	listeners.put(theListener, screen);
	124	}
	125	private final void remove(AccelDeviceEventListener theListener) {
	126	listeners.remove(theListener);
	127	}
	128
	129	/**
	130	* Notifies the listeners associated with the screen's device about the
	131	* event.
	132	*
	133	* Implementation note: the current list of listeners is first duplicated
	134	* which allows the listeners to remove themselves during the iteration.
	135	*
	136	* @param screen a screen number with which the device which is a source of
	137	* the event is associated with
	138	* @param eventType a type of the event
	139	* @see #DEVICE_DISPOSED
	140	* @see #DEVICE_RESET
	141	*/
	142	private final void notifyListeners(int deviceEventType, int screen) {
	143	HashMap<AccelDeviceEventListener, Integer> listClone;
	144	Set<AccelDeviceEventListener> cloneSet;
	145
	146	synchronized(listeners) {
	147	listClone =
	148	new HashMap<AccelDeviceEventListener, Integer>(listeners);
	149	}
	150
	151	cloneSet = listClone.keySet();
	152	Iterator<AccelDeviceEventListener> itr = cloneSet.iterator();
	153	while (itr.hasNext()) {
	154	AccelDeviceEventListener current = itr.next();
	155	Integer i = listClone.get(current);
	156	// only notify listeners which are interested in this device
	157	if (i != null && i.intValue() != screen) {
	158	continue;
	159	}
	160	if (deviceEventType == DEVICE_RESET) {
	161	current.onDeviceReset();
	162	} else if (deviceEventType == DEVICE_DISPOSED) {
	163	current.onDeviceDispose();
	164	}
	165	}
	166	}
	167	}

java/pkg/sun/java2d/pipe/hw/AccelGraphicsConfig.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/AccelGraphicsConfig.java+95−0

@@ -0,0 +1,95 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	import java.awt.image.VolatileImage;
	29
	30	/**
	31	* Implementors of this interface provida a way to create a
	32	* {@code VolatileImage} whose destination surface is an
	33	* {@link AccelSurface} of specified type.
	34	*
	35	* @see AccelSurface
	36	*/
	37	public interface AccelGraphicsConfig extends BufferedContextProvider {
	38	/**
	39	* Returns a VolatileImage with specified width, height, transparency
	40	* and guaranteed accelerated surface type. If such image can not be created
	41	* (out of vram error, specific surface type is not supported) null
	42	* is returned.
	43	*
	44	* Note: if {@link AccelSurface#TEXTURE} type is requested, rendering
	45	* to the image will be denied by throwing
	46	* {@code UnsupportedOperationException }
	47	* from {@link java.awt.image.VolatileImage#getGraphics} and
	48	* {@link java.awt.image.VolatileImage#createGraphics}
	49	*
	50	* @param width the width of the returned {@code VolatileImage}
	51	* @param height the height of the returned {@code VolatileImage}
	52	* @param transparency the specified transparency mode
	53	* @param type requested accelerated surface type as specified by constants
	54	* in AccelSurface interface
	55	* @return a {@code VolatileImage} backed up by requested accelerated
	56	* surface type or null
	57	* @throws IllegalArgumentException if the transparency is not a valid value
	58	* @see AccelSurface#TEXTURE
	59	* @see AccelSurface#RT_PLAIN
	60	* @see AccelSurface#RT_TEXTURE
	61	*/
	62	public VolatileImage createCompatibleVolatileImage(int width, int height,
	63	int transparency,
	64	int type);
	65	/**
	66	* Returns object representing capabilities of the context associated
	67	* with this {@code AccelGraphicsConfig}.
	68	*
	69	* @return ContextCapabilities object representing caps
	70	* @see ContextCapabilities
	71	*/
	72	public ContextCapabilities getContextCapabilities();
	73
	74	/**
	75	* Adds an {@code AccelDeviceEventListener} to listen to accelerated
	76	* device's (which is associated with this {@code AccelGraphicsConfig})
	77	* events.
	78	*
	79	* Note: a hard link to the listener may be kept so it must be explicitly
	80	* removed via {@link #removeDeviceEventListener()}.
	81	*
	82	* @param l the listener
	83	* @see AccelDeviceEventListener
	84	*/
	85	public void addDeviceEventListener(AccelDeviceEventListener l);
	86
	87	/**
	88	* Removes an {@code AccelDeviceEventListener} from the list of listeners
	89	* for this device's events.
	90	*
	91	* @param l the listener
	92	* @see AccelDeviceEventListener
	93	*/
	94	public void removeDeviceEventListener(AccelDeviceEventListener l);
	95	}

java/pkg/sun/java2d/pipe/hw/AccelSurface.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/AccelSurface.java+136−0

@@ -0,0 +1,136 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	import java.awt.Rectangle;
	29	import sun.java2d.Surface;
	30
	31	/**
	32	* Abstraction for a hardware accelerated surface.
	33	*/
	34	public interface AccelSurface extends BufferedContextProvider, Surface {
	35	/**
	36	* Undefined
	37	*/
	38	public static final int UNDEFINED = 0;
	39	/**
	40	* Window (or window substitute) surface
	41	*/
	42	public static final int WINDOW = 1;
	43	/**
	44	* Render-To Plain surface (pbuffer for OpenGL, Render Target surface
	45	* for Direct3D)
	46	*/
	47	public static final int RT_PLAIN = 2;
	48	/**
	49	* Texture surface
	50	*/
	51	public static final int TEXTURE = 3;
	52	/**
	53	* A back-buffer surface (SwapChain surface for Direct3D, backbuffer for
	54	* OpenGL)
	55	*/
	56	public static final int FLIP_BACKBUFFER = 4;
	57	/**
	58	* Render-To Texture surface (fbobject for OpenGL, texture with render-to
	59	* attribute for Direct3D)
	60	*/
	61	public static final int RT_TEXTURE = 5;
	62
	63	/**
	64	* Returns {@code int} representing surface's type as defined by constants
	65	* in this interface.
	66	*
	67	* @return an integer representing this surface's type
	68	* @see AccelSurface#UNDEFINED
	69	* @see AccelSurface#WINDOW
	70	* @see AccelSurface#RT_PLAIN
	71	* @see AccelSurface#TEXTURE
	72	* @see AccelSurface#FLIP_BACKBUFFER
	73	* @see AccelSurface#RT_TEXTURE
	74	*/
	75	public int getType();
	76
	77	/**
	78	* Returns a pointer to the native surface data associated with this
	79	* surface.
	80	* Note: this pointer is only valid on the rendering thread.
	81	*
	82	* @return pointer to the native surface's data
	83	*/
	84	public long getNativeOps();
	85
	86	/**
	87	* Returns a pointer to the real native resource
	88	* of the specified type associated with this AccelSurface.
	89	* Note: this pointer is only valid on the rendering thread.
	90	*
	91	* @param resType the type of the requested resource
	92	* @return a long containing a pointer to the native resource of the
	93	* specified type or 0L if such resource doesn't exist for this surface
	94	*/
	95	public long getNativeResource(int resType);
	96
	97	/**
	98	* Marks this surface dirty.
	99	*/
	100	public void markDirty();
	101
	102	/**
	103	* Returns whether the pipeline considers this surface valid. A surface
	104	* may become invalid if it is disposed of, or resized.
	105	*
	106	* @return true if valid, false otherwise
	107	*/
	108	public boolean isValid();
	109
	110	/**
	111	* Returns whether this surface is lost. The return value is only valid
	112	* on the render thread, meaning that even if this method returns
	113	* {@code true} it could be lost in the next moment unless it is called
	114	* on the rendering thread.
	115	*
	116	* @return true if the surface is known to be lost, false otherwise
	117	*/
	118	public boolean isSurfaceLost();
	119
	120	/**
	121	* Returns the requested bounds of the destination surface. The real bounds
	122	* of the native accelerated surface may differ. Use
	123	* {@link #getNativeBounds} to get the bounds of the native surface.
	124	*
	125	* @return Rectangle representing java surface's bounds
	126	*/
	127	public Rectangle getBounds();
	128
	129	/**
	130	* Returns real bounds of the native surface, which may differ from those
	131	* returned by {@link #getBounds}.
	132	*
	133	* @return Rectangle representing native surface's bounds
	134	*/
	135	public Rectangle getNativeBounds();
	136	}

java/pkg/sun/java2d/pipe/hw/AccelTypedVolatileImage.java+74−0

@@ -0,0 +1,74 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	import java.awt.Graphics;
	29	import java.awt.Graphics2D;
	30	import java.awt.GraphicsConfiguration;
	31	import sun.awt.image.SunVolatileImage;
	32	import static sun.java2d.pipe.hw.AccelSurface.*;
	33
	34	/**
	35	* This is an image with forced type of the accelerated surface.
	36	*/
	37	public class AccelTypedVolatileImage extends SunVolatileImage {
	38
	39	/**
	40	* Creates a volatile image with specified type of accelerated surface.
	41	*
	42	* @param graphicsConfig a GraphicsConfiguration for which this image should
	43	* be created.
	44	* @param width width
	45	* @param height width
	46	* @param transparency type of {@link java.awt.Transparency transparency}
	47	* requested for the image
	48	* @param accType type of the desired accelerated surface as defined in
	49	* AccelSurface interface
	50	* @see sun.java2d.pipe.hw.AccelSurface
	51	*/
	52	public AccelTypedVolatileImage(GraphicsConfiguration graphicsConfig,
	53	int width, int height, int transparency,
	54	int accType)
	55	{
	56	super(null, graphicsConfig, width, height, null, transparency,
	57	null, accType);
	58	}
	59
	60	/**
	61	* {@inheritDoc}
	62	*
	63	* This method will throw {@code UnsupportedOperationException} if it this
	64	* image's destination surface can not be rendered to.
	65	*/
	66	@Override
	67	public Graphics2D createGraphics() {
	68	if (getForcedAccelSurfaceType() == TEXTURE) {
	69	throw new UnsupportedOperationException("Can't render " +
	70	"to a non-RT Texture");
	71	}
	72	return super.createGraphics();
	73	}
	74	}

java/pkg/sun/java2d/pipe/hw/BufferedContextProvider.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/BufferedContextProvider.java+45−0

@@ -0,0 +1,45 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	import sun.java2d.pipe.BufferedContext;
	29
	30	/**
	31	* Classes implementing this interface can provide the {@code BufferedContext}
	32	* associated with or used by them.
	33	*
	34	* @see sun.java2d.pipe.BufferedContext
	35	*/
	36	public interface BufferedContextProvider {
	37	/**
	38	* Retrieves a context associated with object implementing this
	39	* interface.
	40	*
	41	* @return associated context
	42	* @see sun.java2d.pipe.BufferedContext
	43	*/
	44	public BufferedContext getContext();
	45	}

java/pkg/sun/java2d/pipe/hw/ContextCapabilities.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/ContextCapabilities.java+128−0

@@ -0,0 +1,128 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	/**
	29	* Represents a set of capabilities of a BufferedContext and associated
	30	* AccelGraphicsConfig.
	31	*
	32	* @see AccelGraphicsConfig
	33	*/
	34	public class ContextCapabilities {
	35	/** Indicates that the context has no capabilities. */
	36	public static final int CAPS_EMPTY = (0 << 0);
	37	/** Indicates that the context supports RT surfaces with alpha channel. */
	38	public static final int CAPS_RT_PLAIN_ALPHA = (1 << 1);
	39	/** Indicates that the context supports RT textures with alpha channel. */
	40	public static final int CAPS_RT_TEXTURE_ALPHA = (1 << 2);
	41	/** Indicates that the context supports opaque RT textures. */
	42	public static final int CAPS_RT_TEXTURE_OPAQUE = (1 << 3);
	43	/** Indicates that the context supports multitexturing. */
	44	public static final int CAPS_MULTITEXTURE = (1 << 4);
	45	/** Indicates that the context supports non-pow2 texture dimensions. */
	46	public static final int CAPS_TEXNONPOW2 = (1 << 5);
	47	/** Indicates that the context supports non-square textures. */
	48	public static final int CAPS_TEXNONSQUARE = (1 << 6);
	49	/** Indicates that the context supports pixel shader 2.0 or better. */
	50	public static final int CAPS_PS20 = (1 << 7);
	51	/** Indicates that the context supports pixel shader 3.0 or better. */
	52	public static final int CAPS_PS30 = (1 << 8);
	53	/*
	54	* Pipeline contexts should use this for defining pipeline-specific
	55	* capabilities, for example:
	56	* int CAPS_D3D_1 = (FIRST_PRIVATE_CAP << 0);
	57	* int CAPS_D3D_2 = (FIRST_PRIVATE_CAP << 1);
	58	*/
	59	protected static final int FIRST_PRIVATE_CAP = (1 << 16);
	60
	61	protected final int caps;
	62	protected final String adapterId;
	63
	64	/**
	65	* Constructs a {@code ContextCapabilities} object.
	66	* @param caps an {@code int} representing the capabilities
	67	* @param a {@code String} representing the name of the adapter, or null,
	68	* in which case the adapterId will be set to "unknown adapter".
	69	*/
	70	protected ContextCapabilities(int caps, String adapterId) {
	71	this.caps = caps;
	72	this.adapterId = adapterId != null ? adapterId : "unknown adapter";
	73	}
	74
	75	/**
	76	* Returns a string representing the name of the graphics adapter if such
	77	* could be determined. It is guaranteed to never return {@code null}.
	78	* @return string representing adapter id
	79	*/
	80	public String getAdapterId() {
	81	return adapterId;
	82	}
	83
	84	/**
	85	* Returns an {@code int} with capabilities (OR-ed constants defined in
	86	* this class and its pipeline-specific subclasses).
	87	* @return capabilities as {@code int}
	88	*/
	89	public int getCaps() {
	90	return caps;
	91	}
	92
	93	@Override
	94	public String toString() {
	95	StringBuffer buf =
	96	new StringBuffer("ContextCapabilities: adapter=" +
	97	adapterId+", caps=");
	98	if (caps == CAPS_EMPTY) {
	99	buf.append("CAPS_EMPTY");
	100	} else {
	101	if ((caps & CAPS_RT_PLAIN_ALPHA) != 0) {
	102	buf.append("CAPS_RT_PLAIN_ALPHA\|");
	103	}
	104	if ((caps & CAPS_RT_TEXTURE_ALPHA) != 0) {
	105	buf.append("CAPS_RT_TEXTURE_ALPHA\|");
	106	}
	107	if ((caps & CAPS_RT_TEXTURE_OPAQUE) != 0) {
	108	buf.append("CAPS_RT_TEXTURE_OPAQUE\|");
	109	}
	110	if ((caps & CAPS_MULTITEXTURE) != 0) {
	111	buf.append("CAPS_MULTITEXTURE\|");
	112	}
	113	if ((caps & CAPS_TEXNONPOW2) != 0) {
	114	buf.append("CAPS_TEXNONPOW2\|");
	115	}
	116	if ((caps & CAPS_TEXNONSQUARE) != 0) {
	117	buf.append("CAPS_TEXNONSQUARE\|");
	118	}
	119	if ((caps & CAPS_PS20) != 0) {
	120	buf.append("CAPS_PS20\|");
	121	}
	122	if ((caps & CAPS_PS30) != 0) {
	123	buf.append("CAPS_PS30\|");
	124	}
	125	}
	126	return buf.toString();
	127	}
	128	}

java/pkg/sun/java2d/pipe/hw/ExtendedBufferCapabilities$VSyncType.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/ExtendedBufferCapabilities.class+0−0

Binary file not shown.

java/pkg/sun/java2d/pipe/hw/ExtendedBufferCapabilities.java+154−0

@@ -0,0 +1,154 @@
	1	/*
	2	* Copyright (c) 2007, 2008, 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.java2d.pipe.hw;
	27
	28	import java.awt.BufferCapabilities;
	29	import java.awt.ImageCapabilities;
	30
	31	/**
	32	* Provides extended BufferStrategy capabilities, allowing to specify
	33	* the type of vertical refresh synchronization for a buffer strategy.
	34	*
	35	* This BS capability is always page flipping because v-sync is only relevant
	36	* to flipping buffer strategies.
	37	*
	38	* Note that asking for a v-synced BS doesn't necessarily guarantee that it will
	39	* be v-synced since the vsync capability may be disabled in the driver, or
	40	* there may be other restriction (like a number of v-synced buffer strategies
	41	* allowed per vm). Because of this {@code createBufferStrategy} doesn't
	42	* throw {@code AWTException} when a v-synced BS could not be created when
	43	* requested.
	44	*
	45	* @see java.awt.Canvas#createBufferStrategy(int, BufferCapabilities)
	46	* @see java.awt.Window#createBufferStrategy(int, BufferCapabilities)
	47	*/
	48	public class ExtendedBufferCapabilities extends BufferCapabilities {
	49
	50	/**
	51	* Type of synchronization on vertical retrace.
	52	*/
	53	public static enum VSyncType {
	54	/**
	55	* Use the default v-sync mode appropriate for given BufferStrategy
	56	* and situation.
	57	*/
	58	VSYNC_DEFAULT(0),
	59
	60	/**
	61	* Synchronize flip on vertical retrace.
	62	*/
	63	VSYNC_ON(1),
	64
	65	/**
	66	* Do not synchronize flip on vertical retrace.
	67	*/
	68	VSYNC_OFF(2);
	69
	70	/**
	71	* Used to identify the v-sync type (independent of the constants
	72	* order as opposed to {@code ordinal()}).
	73	*/
	74	public int id() {
	75	return id;
	76	}
	77
	78	private VSyncType(int id) {
	79	this.id = id;
	80	}
	81	private int id;
	82	}
	83
	84	private VSyncType vsync;
	85
	86	/**
	87	* Creates an ExtendedBufferCapabilities object with front/back/flip caps
	88	* from the passed cap, and VSYNC_DEFAULT v-sync mode.
	89	*/
	90	public ExtendedBufferCapabilities(BufferCapabilities caps) {
	91	super(caps.getFrontBufferCapabilities(),
	92	caps.getBackBufferCapabilities(),
	93	caps.getFlipContents());
	94
	95	this.vsync = VSyncType.VSYNC_DEFAULT;
	96	}
	97
	98	/**
	99	* Creates an ExtendedBufferCapabilities instance with front/back/flip caps
	100	* from the passed caps, and VSYNC_DEFAULT v-sync mode.
	101	*/
	102	public ExtendedBufferCapabilities(ImageCapabilities front,
	103	ImageCapabilities back, FlipContents flip)
	104	{
	105	super(front, back, flip);
	106
	107	this.vsync = VSyncType.VSYNC_DEFAULT;
	108	}
	109
	110	/**
	111	* Creates an ExtendedBufferCapabilities instance with front/back/flip caps
	112	* from the passed image/flip caps, and the v-sync type.
	113	*/
	114	public ExtendedBufferCapabilities(ImageCapabilities front,
	115	ImageCapabilities back, FlipContents flip,
	116	VSyncType t)
	117	{
	118	super(front, back, flip);
	119
	120	this.vsync = t;
	121	}
	122
	123	/**
	124	* Creates an ExtendedBufferCapabilities instance with front/back/flip caps
	125	* from the passed cap, and the passed v-sync mode.
	126	*/
	127	public ExtendedBufferCapabilities(BufferCapabilities caps, VSyncType t) {
	128	super(caps.getFrontBufferCapabilities(),
	129	caps.getBackBufferCapabilities(),
	130	caps.getFlipContents());
	131
	132	this.vsync = t;
	133	}
	134
	135	/**
	136	* Creates an ExtendedBufferCapabilities instance with front/back/flip caps
	137	* from the object, and passed v-sync mode.
	138	*/
	139	public ExtendedBufferCapabilities derive(VSyncType t) {
	140	return new ExtendedBufferCapabilities(this, t);
	141	}
	142
	143	/**
	144	* Returns the type of v-sync requested by this capabilities instance.
	145	*/
	146	public VSyncType getVSync() {
	147	return vsync;
	148	}
	149
	150	@Override
	151	public final boolean isPageFlipping() {
	152	return true;
	153	}
	154	}

java/pkg/sun/java2d/pipe/hw/mkfile+15−0

@@ -0,0 +1,15 @@
	1	<../../../../../../mkconfig
	2
	3	TARG=\
	4	AccelDeviceEventListener.dis\
	5	AccelDeviceEventNotifier.dis\
	6	AccelGraphicsConfig.dis\
	7	AccelSurface.dis\
	8	AccelTypedVolatileImage.dis\
	9	BufferedContextProvider.dis\
	10	ContextCapabilities.dis\
	11	ExtendedBufferCapabilities.dis\
	12
	13	DISBIN=$ROOT/java/dis/java/java/sun/java2d/pipe/hw
	14
	15	<$ROOT/mkfiles/mkjava

java/pkg/sun/java2d/pipe/mkfile+56−0

@@ -0,0 +1,56 @@
	1	<../../../../../mkconfig
	2
	3	DIRS=\
	4	hw\
	5
	6	TARG=\
	7	AAShapePipe.dis\
	8	AATextRenderer.dis\
	9	AATileGenerator.dis\
	10	AlphaColorPipe.dis\
	11	AlphaPaintPipe.dis\
	12	BufferedBufImgOps.dis\
	13	BufferedContext.dis\
	14	BufferedMaskBlit.dis\
	15	BufferedMaskFill.dis\
	16	BufferedOpCodes.dis\
	17	BufferedPaints.dis\
	18	BufferedRenderPipe.dis\
	19	BufferedTextPipe.dis\
	20	CompositePipe.dis\
	21	DrawImage.dis\
	22	DrawImagePipe.dis\
	23	GeneralCompositePipe.dis\
	24	GlyphListLoopPipe.dis\
	25	GlyphListPipe.dis\
	26	LCDTextRenderer.dis\
	27	LoopBasedPipe.dis\
	28	LoopPipe.dis\
	29	NullPipe.dis\
	30	OutlineTextRenderer.dis\
	31	ParallelogramPipe.dis\
	32	PixelDrawPipe.dis\
	33	PixelFillPipe.dis\
	34	PixelToParallelogramConverter.dis\
	35	PixelToShapeConverter.dis\
	36	Region.dis\
	37	RegionClipSpanIterator.dis\
	38	RegionIterator.dis\
	39	RegionSpanIterator.dis\
	40	RenderBuffer.dis\
	41	RenderingEngine.dis\
	42	RenderQueue.dis\
	43	ShapeDrawPipe.dis\
	44	ShapeSpanIterator.dis\
	45	SolidTextRenderer.dis\
	46	SpanClipRenderer.dis\
	47	SpanIterator.dis\
	48	SpanShapeRenderer.dis\
	49	TextPipe.dis\
	50	TextRenderer.dis\
	51	ValidatePipe.dis\
	52
	53	DISBIN=$ROOT/java/dis/java/java/sun/java2d/pipe
	54
	55	<$ROOT/mkfiles/mkjava
	56	<$ROOT/mkfiles/mksubdirs