plan9-archive/inferno-java

java/pkg/sun/java2d/DefaultDisposerRecord.class+0−0

Binary file not shown.

java/pkg/sun/java2d/DefaultDisposerRecord.java+56−0

@@ -0,0 +1,56 @@
	1	/*
	2	* Copyright (c) 2002, 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;
	27
	28	/**
	29	* This class is the default DisposerRecord implementation which
	30	* holds pointers to the native disposal method and the data to be disposed.
	31	*/
	32	public class DefaultDisposerRecord implements DisposerRecord {
	33	private long dataPointer;
	34	private long disposerMethodPointer;
	35
	36	public DefaultDisposerRecord(long disposerMethodPointer, long dataPointer) {
	37	this.disposerMethodPointer = disposerMethodPointer;
	38	this.dataPointer = dataPointer;
	39	}
	40
	41	public void dispose() {
	42	invokeNativeDispose(disposerMethodPointer,
	43	dataPointer);
	44	}
	45
	46	public long getDataPointer() {
	47	return dataPointer;
	48	}
	49
	50	public long getDisposerMethodPointer() {
	51	return disposerMethodPointer;
	52	}
	53
	54	public static native void invokeNativeDispose(long disposerMethodPointer,
	55	long dataPointer);
	56	}

java/pkg/sun/java2d/DestSurfaceProvider.class+0−0

Binary file not shown.

java/pkg/sun/java2d/DestSurfaceProvider.java+41−0

@@ -0,0 +1,41 @@
	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;
	27
	28	import sun.java2d.pipe.hw.*;
	29
	30	/**
	31	* Classes implementing this interface provide access to their
	32	* destination surfaces.
	33	*/
	34	public interface DestSurfaceProvider {
	35	/**
	36	* Returns a surface currently used as a destination surface for rendering.
	37	*
	38	* @return destination surface
	39	*/
	40	public Surface getDestSurface();
	41	}

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

Binary file not shown.

java/pkg/sun/java2d/Disposer$PollDisposable.class+0−0

Binary file not shown.

java/pkg/sun/java2d/Disposer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/Disposer.java+262−0

@@ -0,0 +1,262 @@
	1	/*
	2	* Copyright (c) 2002, 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;
	27
	28	import java.lang.ref.Reference;
	29	import java.lang.ref.ReferenceQueue;
	30	import java.lang.ref.PhantomReference;
	31	import java.lang.ref.WeakReference;
	32	import java.util.ArrayList;
	33	import java.util.Hashtable;
	34
	35	/**
	36	* This class is used for registering and disposing the native
	37	* data associated with java objects.
	38	*
	39	* The object can register itself by calling one of the addRecord
	40	* methods and providing either the pointer to the native disposal
	41	* method or a descendant of the DisposerRecord class with overridden
	42	* dispose() method.
	43	*
	44	* When the object becomes unreachable, the dispose() method
	45	* of the associated DisposerRecord object will be called.
	46	*
	47	* @see DisposerRecord
	48	*/
	49	public class Disposer implements Runnable {
	50	private static final ReferenceQueue queue = new ReferenceQueue();
	51	private static final Hashtable records = new Hashtable();
	52
	53	private static Disposer disposerInstance;
	54	public static final int WEAK = 0;
	55	public static final int PHANTOM = 1;
	56	public static int refType = PHANTOM;
	57
	58	static {
	59	java.security.AccessController.doPrivileged(
	60	new sun.security.action.LoadLibraryAction("awt"));
	61	initIDs();
	62	String type = (String) java.security.AccessController.doPrivileged(
	63	new sun.security.action.GetPropertyAction("sun.java2d.reftype"));
	64	if (type != null) {
	65	if (type.equals("weak")) {
	66	refType = WEAK;
	67	System.err.println("Using WEAK refs");
	68	} else {
	69	refType = PHANTOM;
	70	System.err.println("Using PHANTOM refs");
	71	}
	72	}
	73	disposerInstance = new Disposer();
	74	java.security.AccessController.doPrivileged(
	75	new java.security.PrivilegedAction() {
	76	public Object run() {
	77	/* The thread must be a member of a thread group
	78	* which will not get GCed before VM exit.
	79	* Make its parent the top-level thread group.
	80	*/
	81	ThreadGroup tg = Thread.currentThread().getThreadGroup();
	82	for (ThreadGroup tgn = tg;
	83	tgn != null;
	84	tg = tgn, tgn = tg.getParent());
	85	Thread t =
	86	new Thread(tg, disposerInstance, "Java2D Disposer");
	87	t.setContextClassLoader(null);
	88	t.setDaemon(true);
	89	t.setPriority(Thread.MAX_PRIORITY);
	90	t.start();
	91	return null;
	92	}
	93	}
	94	);
	95	}
	96
	97	/**
	98	* Registers the object and the native data for later disposal.
	99	* @param target Object to be registered
	100	* @param disposeMethod pointer to the native disposal method
	101	* @param pData pointer to the data to be passed to the
	102	* native disposal method
	103	*/
	104	public static void addRecord(Object target,
	105	long disposeMethod, long pData)
	106	{
	107	disposerInstance.add(target,
	108	new DefaultDisposerRecord(disposeMethod, pData));
	109	}
	110
	111	/**
	112	* Registers the object and the native data for later disposal.
	113	* @param target Object to be registered
	114	* @param rec the associated DisposerRecord object
	115	* @see DisposerRecord
	116	*/
	117	public static void addRecord(Object target, DisposerRecord rec) {
	118	disposerInstance.add(target, rec);
	119	}
	120
	121	/**
	122	* Performs the actual registration of the target object to be disposed.
	123	* @param target Object to be registered, or if target is an instance
	124	* of DisposerTarget, its associated disposer referent
	125	* will be the Object that is registered
	126	* @param rec the associated DisposerRecord object
	127	* @see DisposerRecord
	128	*/
	129	synchronized void add(Object target, DisposerRecord rec) {
	130	if (target instanceof DisposerTarget) {
	131	target = ((DisposerTarget)target).getDisposerReferent();
	132	}
	133	java.lang.ref.Reference ref;
	134	if (refType == PHANTOM) {
	135	ref = new PhantomReference(target, queue);
	136	} else {
	137	ref = new WeakReference(target, queue);
	138	}
	139	records.put(ref, rec);
	140	}
	141
	142	public void run() {
	143	while (true) {
	144	try {
	145	Object obj = queue.remove();
	146	((Reference)obj).clear();
	147	DisposerRecord rec = (DisposerRecord)records.remove(obj);
	148	rec.dispose();
	149	obj = null;
	150	rec = null;
	151	clearDeferredRecords();
	152	} catch (Exception e) {
	153	System.out.println("Exception while removing reference: " + e);
	154	e.printStackTrace();
	155	}
	156	}
	157	}
	158
	159	/*
	160	* This is a marker interface that, if implemented, means it
	161	* doesn't acquire any special locks, and is safe to
	162	* be disposed in the poll loop on whatever thread
	163	* which happens to be the Toolkit thread, is in use.
	164	*/
	165	public static interface PollDisposable {
	166	};
	167
	168	private static ArrayList<DisposerRecord> deferredRecords = null;
	169
	170	private static void clearDeferredRecords() {
	171	if (deferredRecords == null \|\| deferredRecords.isEmpty()) {
	172	return;
	173	}
	174	for (int i=0;i<deferredRecords.size(); i++) {
	175	try {
	176	DisposerRecord rec = deferredRecords.get(i);
	177	rec.dispose();
	178	} catch (Exception e) {
	179	System.out.println("Exception while disposing deferred rec.");
	180	e.printStackTrace();
	181	}
	182	}
	183	deferredRecords.clear();
	184	}
	185
	186	/*
	187	* Set to indicate the queue is presently being polled.
	188	*/
	189	public static volatile boolean pollingQueue = false;
	190
	191	/*
	192	* The pollRemove() method is called back from a dispose method
	193	* that is running on the toolkit thread and wants to
	194	* dispose any pending refs that are safe to be disposed
	195	* on that thread.
	196	*/
	197	public static void pollRemove() {
	198
	199	/* This should never be called recursively, so this check
	200	* is just a safeguard against the unexpected.
	201	*/
	202	if (pollingQueue) {
	203	return;
	204	}
	205	Object obj;
	206	pollingQueue = true;
	207	int freed = 0;
	208	int deferred = 0;
	209	try {
	210	while ((obj = queue.poll()) != null
	211	&& freed < 10000 && deferred < 100) {
	212	freed++;
	213	((Reference)obj).clear();
	214	DisposerRecord rec = (DisposerRecord)records.remove(obj);
	215	if (rec instanceof PollDisposable) {
	216	rec.dispose();
	217	obj = null;
	218	rec = null;
	219	} else {
	220	if (rec == null) { // shouldn't happen, but just in case.
	221	continue;
	222	}
	223	deferred++;
	224	if (deferredRecords == null) {
	225	deferredRecords = new ArrayList<DisposerRecord>(5);
	226	}
	227	deferredRecords.add(rec);
	228	}
	229	}
	230	} catch (Exception e) {
	231	System.out.println("Exception while removing reference: " + e);
	232	e.printStackTrace();
	233	} finally {
	234	pollingQueue = false;
	235	}
	236	}
	237
	238	private static native void initIDs();
	239
	240	/*
	241	* This was added for use by the 2D font implementation to avoid creation
	242	* of an additional disposer thread.
	243	* WARNING: this thread class monitors a specific queue, so a reference
	244	* added here must have been created with this queue. Failure to do
	245	* so will clutter the records hashmap and no one will be cleaning up
	246	* the reference queue.
	247	*/
	248	public static void addReference(Reference ref, DisposerRecord rec) {
	249	records.put(ref, rec);
	250	}
	251
	252	public static void addObjectRecord(Object obj, DisposerRecord rec) {
	253	records.put(new WeakReference(obj, queue) , rec);
	254	}
	255
	256	/* This is intended for use in conjunction with addReference(..)
	257	*/
	258	public static ReferenceQueue getQueue() {
	259	return queue;
	260	}
	261
	262	}

java/pkg/sun/java2d/DisposerRecord.class+0−0

Binary file not shown.

java/pkg/sun/java2d/DisposerRecord.java+34−0

@@ -0,0 +1,34 @@
	1	/*
	2	* Copyright (c) 2002, 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;
	27
	28	/**
	29	* This class is used to hold the resource to be
	30	* disposed.
	31	*/
	32	public interface DisposerRecord {
	33	public void dispose();
	34	}

java/pkg/sun/java2d/DisposerTarget.class+0−0

Binary file not shown.

java/pkg/sun/java2d/DisposerTarget.java+38−0

@@ -0,0 +1,38 @@
	1	/*
	2	* Copyright (c) 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;
	27
	28	/**
	29	* This is an interface which should be implemented by
	30	* the classes which use Disposer.
	31	*/
	32	public interface DisposerTarget {
	33	/**
	34	* Returns an object which will be
	35	* used as the referent in the ReferenceQueue
	36	*/
	37	public Object getDisposerReferent();
	38	}

java/pkg/sun/java2d/FontSupport.class+0−0

Binary file not shown.

java/pkg/sun/java2d/FontSupport.java+39−0

@@ -0,0 +1,39 @@
	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;
	27
	28	import sun.awt.FontConfiguration;
	29
	30	/**
	31	* Font support for graphics environment
	32	*/
	33	public interface FontSupport {
	34
	35	/**
	36	* Returns the current font configuration.
	37	*/
	38	public FontConfiguration getFontConfiguration();
	39	}

java/pkg/sun/java2d/HeadlessGraphicsEnvironment.class+0−0

Binary file not shown.

java/pkg/sun/java2d/HeadlessGraphicsEnvironment.java+103−0

@@ -0,0 +1,103 @@
	1	/*
	2	* Copyright (c) 2000, 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;
	27
	28	import java.awt.GraphicsEnvironment;
	29	import java.awt.GraphicsDevice;
	30	import java.awt.Graphics2D;
	31	import java.awt.HeadlessException;
	32	import java.awt.image.BufferedImage;
	33	import java.awt.Font;
	34	import java.text.AttributedCharacterIterator;
	35	import java.awt.print.PrinterJob;
	36	import java.util.Map;
	37	import java.util.Hashtable;
	38	import java.util.Locale;
	39	import java.util.Vector;
	40	import java.util.StringTokenizer;
	41	import java.util.ResourceBundle;
	42	import java.util.MissingResourceException;
	43	import java.io.IOException;
	44	import java.io.FilenameFilter;
	45	import java.io.File;
	46	import java.util.NoSuchElementException;
	47	import sun.awt.FontConfiguration;
	48	import java.util.TreeMap;
	49	import java.util.Set;
	50	import java.awt.font.TextAttribute;
	51	import java.io.InputStream;
	52	import java.io.FileInputStream;
	53	import java.io.BufferedInputStream;
	54	import java.util.Properties;
	55	import java.awt.Point;
	56	import java.awt.Rectangle;
	57
	58	/**
	59	* Headless decorator implementation of a SunGraphicsEnvironment
	60	*/
	61
	62	public class HeadlessGraphicsEnvironment extends GraphicsEnvironment {
	63
	64	private GraphicsEnvironment ge;
	65
	66	public HeadlessGraphicsEnvironment(GraphicsEnvironment ge) {
	67	this.ge = ge;
	68	}
	69
	70	public GraphicsDevice[] getScreenDevices()
	71	throws HeadlessException {
	72	throw new HeadlessException();
	73	}
	74
	75	public GraphicsDevice getDefaultScreenDevice()
	76	throws HeadlessException {
	77	throw new HeadlessException();
	78	}
	79
	80	public Point getCenterPoint() throws HeadlessException {
	81	throw new HeadlessException();
	82	}
	83
	84	public Rectangle getMaximumWindowBounds() throws HeadlessException {
	85	throw new HeadlessException();
	86	}
	87
	88	public Graphics2D createGraphics(BufferedImage img) {
	89	return ge.createGraphics(img); }
	90
	91	public Font[] getAllFonts() { return ge.getAllFonts(); }
	92
	93	public String[] getAvailableFontFamilyNames() {
	94	return ge.getAvailableFontFamilyNames(); }
	95
	96	public String[] getAvailableFontFamilyNames(Locale l) {
	97	return ge.getAvailableFontFamilyNames(l); }
	98
	99	/* Used by FontManager : internal API */
	100	public GraphicsEnvironment getSunGraphicsEnvironment() {
	101	return ge;
	102	}
	103	}

java/pkg/sun/java2d/InvalidPipeException.class+0−0

Binary file not shown.

java/pkg/sun/java2d/InvalidPipeException.java+55−0

@@ -0,0 +1,55 @@
	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;
	27
	28	/**
	29	* Signals that some part of a graphics pipeline is not in an appropriate
	30	* state for the requested operation. The most likely cause of this is
	31	* an asynchronous change to the configuration of the destination surface
	32	* since the current set of rendering loops was chosen. Other potential
	33	* causes are the appearance or disappearance of overlapping opaque
	34	* windows which toggle the need to use platform graphics or direct
	35	* graphics access.
	36	*/
	37	public class InvalidPipeException extends IllegalStateException {
	38	/**
	39	* Constructs an InvalidPipeException with no detail message.
	40	* A detail message is a String that describes this particular exception.
	41	*/
	42	public InvalidPipeException() {
	43	super();
	44	}
	45
	46	/**
	47	* Constructs an InvalidPipeException with the specified detail
	48	* message. A detail message is a String that describes this particular
	49	* exception.
	50	* @param s the String that contains a detailed message
	51	*/
	52	public InvalidPipeException(String s) {
	53	super(s);
	54	}
	55	}

java/pkg/sun/java2d/NullSurfaceData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/NullSurfaceData.java+159−0

@@ -0,0 +1,159 @@
	1	/*
	2	* Copyright (c) 2002, 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;
	27
	28	import java.awt.Rectangle;
	29	import java.awt.image.Raster;
	30	import java.awt.image.ColorModel;
	31	import java.awt.GraphicsConfiguration;
	32
	33	import sun.java2d.StateTrackable.State;
	34	import sun.java2d.loops.SurfaceType;
	35	import sun.java2d.pipe.NullPipe;
	36
	37	/**
	38	* This class provides an empty implementation of the SurfaceData
	39	* abstract superclass. All operations on it translate into NOP
	40	* or harmless operations.
	41	*/
	42	public class NullSurfaceData extends SurfaceData {
	43	public static final SurfaceData theInstance = new NullSurfaceData();
	44
	45	private NullSurfaceData() {
	46	super(State.IMMUTABLE, SurfaceType.Any, ColorModel.getRGBdefault());
	47	}
	48
	49	/**
	50	* Sets this SurfaceData object to the invalid state. All Graphics
	51	* objects must get a new SurfaceData object via the refresh method
	52	* and revalidate their pipelines before continuing.
	53	*/
	54	public void invalidate() {
	55	}
	56
	57	/**
	58	* Return a new SurfaceData object that represents the current state
	59	* of the destination that this SurfaceData object describes.
	60	* This method is typically called when the SurfaceData is invalidated.
	61	*/
	62	public SurfaceData getReplacement() {
	63	return this;
	64	}
	65
	66	private final static NullPipe nullpipe = new NullPipe();
	67
	68	public void validatePipe(SunGraphics2D sg2d) {
	69	sg2d.drawpipe = nullpipe;
	70	sg2d.fillpipe = nullpipe;
	71	sg2d.shapepipe = nullpipe;
	72	sg2d.textpipe = nullpipe;
	73	sg2d.imagepipe = nullpipe;
	74	}
	75
	76	public GraphicsConfiguration getDeviceConfiguration() {
	77	return null;
	78	}
	79
	80	/**
	81	* Return a readable Raster which contains the pixels for the
	82	* specified rectangular region of the destination surface.
	83	* The coordinate origin of the returned Raster is the same as
	84	* the device space origin of the destination surface.
	85	* In some cases the returned Raster might also be writeable.
	86	* In most cases, the returned Raster might contain more pixels
	87	* than requested.
	88	*
	89	* @see useTightBBoxes
	90	*/
	91	public Raster getRaster(int x, int y, int w, int h) {
	92	throw new InvalidPipeException("should be NOP");
	93	}
	94
	95	/**
	96	* Does the pixel accessibility of the destination surface
	97	* suggest that rendering algorithms might want to take
	98	* extra time to calculate a more accurate bounding box for
	99	* the operation being performed?
	100	* The typical case when this will be true is when a copy of
	101	* the pixels has to be made when doing a getRaster. The
	102	* fewer pixels copied, the faster the operation will go.
	103	*
	104	* @see getRaster
	105	*/
	106	public boolean useTightBBoxes() {
	107	return false;
	108	}
	109
	110	/**
	111	* Returns the pixel data for the specified Argb value packed
	112	* into an integer for easy storage and conveyance.
	113	*/
	114	public int pixelFor(int rgb) {
	115	return rgb;
	116	}
	117
	118	/**
	119	* Returns the Argb representation for the specified integer value
	120	* which is packed in the format of the associated ColorModel.
	121	*/
	122	public int rgbFor(int pixel) {
	123	return pixel;
	124	}
	125
	126	/**
	127	* Returns the bounds of the destination surface.
	128	*/
	129	public Rectangle getBounds() {
	130	return new Rectangle();
	131	}
	132
	133	/**
	134	* Performs Security Permissions checks to see if a Custom
	135	* Composite object should be allowed access to the pixels
	136	* of this surface.
	137	*/
	138	protected void checkCustomComposite() {
	139	return;
	140	}
	141
	142	/**
	143	* Performs a copyarea within this surface. Returns
	144	* false if there is no algorithm to perform the copyarea
	145	* given the current settings of the SunGraphics2D.
	146	*/
	147	public boolean copyArea(SunGraphics2D sg2d,
	148	int x, int y, int w, int h, int dx, int dy)
	149	{
	150	return true;
	151	}
	152
	153	/**
	154	* Returns destination Image associated with this SurfaceData (null)
	155	*/
	156	public Object getDestination() {
	157	return null;
	158	}
	159	}

java/pkg/sun/java2d/Spans.java+393−0

@@ -0,0 +1,393 @@
	1	/*
	2	* Copyright (c) 1998, 2000, 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;
	27
	28	import java.util.Comparator;
	29	import java.util.Collections;
	30	import java.util.Iterator;
	31	import java.util.List;
	32	import java.util.Vector;
	33
	34	/**
	35	* Maintains a list of half-open intervals, called Spans.
	36	* A Span can be tested against the list of Spans
	37	* for intersection.
	38	*/
	39	public class Spans {
	40
	41	/**
	42	* This class will sort and collapse its span
	43	* entries after this many span additions via
	44	* the <code>add</code> method.
	45	*/
	46	private static final int kMaxAddsSinceSort = 256;
	47
	48	/**
	49	* Holds a list of individual
	50	* Span instances.
	51	*/
	52	private List mSpans = new Vector(kMaxAddsSinceSort);
	53
	54	/**
	55	* The number of <code>Span</code>
	56	* instances that have been added
	57	* to this object without a sort
	58	* and collapse taking place.
	59	*/
	60	private int mAddsSinceSort = 0;
	61
	62	public Spans() {
	63
	64	}
	65
	66	/**
	67	* Add a span covering the half open interval
	68	* including <code>start</code> up to
	69	* but not including <code>end</code>.
	70	*/
	71	public void add(float start, float end) {
	72
	73	if (mSpans != null) {
	74	mSpans.add(new Span(start, end));
	75
	76	if (++mAddsSinceSort >= kMaxAddsSinceSort) {
	77	sortAndCollapse();
	78	}
	79	}
	80	}
	81
	82	/**
	83	* Add a span which covers the entire range.
	84	* This call is logically equivalent to
	85	* <code>add(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY)</code>
	86	* The result of making this call is that
	87	* all future <code>add</code> calls are ignored
	88	* and the <code>intersects</code> method always
	89	* returns true.
	90	*/
	91	public void addInfinite() {
	92	mSpans = null;
	93	}
	94
	95	/**
	96	* Returns true if the span defined by the half-open
	97	* interval from <code>start</code> up to,
	98	* but not including, <code>end</code> intersects
	99	* any of the spans defined by this instance.
	100	*/
	101	public boolean intersects(float start, float end) {
	102	boolean doesIntersect;
	103
	104	if (mSpans != null) {
	105
	106	/* If we have added any spans since we last
	107	* sorted and collapsed our list of spans
	108	* then we need to resort and collapse.
	109	*/
	110	if (mAddsSinceSort > 0) {
	111	sortAndCollapse();
	112	}
	113
	114	/* The SpanIntersection comparator considers
	115	* two spans equal if they intersect. If
	116	* the search finds a match then we have an
	117	* intersection.
	118	*/
	119	int found = Collections.binarySearch(mSpans,
	120	new Span(start, end),
	121	SpanIntersection.instance);
	122
	123	doesIntersect = found >= 0;
	124
	125	/* The addInfinite() method has been invoked so
	126	* everything intersect this instance.
	127	*/
	128	} else {
	129	doesIntersect = true;
	130	}
	131
	132	return doesIntersect;
	133	}
	134
	135	/**
	136	* Sort the spans in ascending order by their
	137	* start position. After the spans are sorted
	138	* collapse any spans that intersect into a
	139	* single span. The result is a sorted,
	140	* non-overlapping list of spans.
	141	*/
	142	private void sortAndCollapse() {
	143
	144	Collections.sort(mSpans);
	145	mAddsSinceSort = 0;
	146
	147	Iterator iter = mSpans.iterator();
	148
	149	/* Have 'span' start at the first span in
	150	* the collection. The collection may be empty
	151	* so we're careful.
	152	*/
	153	Span span = null;
	154	if (iter.hasNext()) {
	155	span = (Span) iter.next();
	156	}
	157
	158	/* Loop over the spans collapsing those that intersect
	159	* into a single span.
	160	*/
	161	while (iter.hasNext()) {
	162
	163	Span nextSpan = (Span) iter.next();
	164
	165	/* The spans are in ascending start position
	166	* order and so the next span's starting point
	167	* is either in the span we are trying to grow
	168	* or it is beyond the first span and thus the
	169	* two spans do not intersect.
	170	*
	171	* span: <----------<
	172	* nextSpan: <------ (intersects)
	173	* nextSpan: <------ (doesn't intersect)
	174	*
	175	* If the spans intersect then we'll remove
	176	* nextSpan from the list. If nextSpan's
	177	* ending was beyond the first's then
	178	* we extend the first.
	179	*
	180	* span: <----------<
	181	* nextSpan: <-----< (don't change span)
	182	* nextSpan: <-----------< (grow span)
	183	*/
	184
	185	if (span.subsume(nextSpan)) {
	186	iter.remove();
	187
	188	/* The next span did not intersect the current
	189	* span and so it can not be collapsed. Instead
	190	* it becomes the start of the next set of spans
	191	* to be collapsed.
	192	*/
	193	} else {
	194	span = nextSpan;
	195	}
	196	}
	197	}
	198
	199	/*
	200	// For debugging.
	201
	202	private void printSpans() {
	203	System.out.println("----------");
	204	if (mSpans != null) {
	205	Iterator iter = mSpans.iterator();
	206	while (iter.hasNext()) {
	207	Span span = (Span) iter.next();
	208	System.out.println(span);
	209	}
	210	}
	211	System.out.println("----------");
	212
	213	}
	214	*/
	215
	216	/**
	217	* Holds a single half-open interval.
	218	*/
	219	static class Span implements Comparable {
	220
	221	/**
	222	* The span includes the starting point.
	223	*/
	224	private float mStart;
	225
	226	/**
	227	* The span goes up to but does not include
	228	* the ending point.
	229	*/
	230	private float mEnd;
	231
	232	/**
	233	* Create a half-open interval including
	234	* <code>start</code> but not including
	235	* <code>end</code>.
	236	*/
	237	Span(float start, float end) {
	238	mStart = start;
	239	mEnd = end;
	240	}
	241
	242	/**
	243	* Return the start of the <code>Span</code>.
	244	* The start is considered part of the
	245	* half-open interval.
	246	*/
	247	final float getStart() {
	248	return mStart;
	249	}
	250
	251	/**
	252	* Return the end of the <code>Span</code>.
	253	* The end is not considered part of the
	254	* half-open interval.
	255	*/
	256	final float getEnd() {
	257	return mEnd;
	258	}
	259
	260	/**
	261	* Change the initial position of the
	262	* <code>Span</code>.
	263	*/
	264	final void setStart(float start) {
	265	mStart = start;
	266	}
	267
	268	/**
	269	* Change the terminal position of the
	270	* <code>Span</code>.
	271	*/
	272	final void setEnd(float end) {
	273	mEnd = end;
	274	}
	275
	276	/**
	277	* Attempt to alter this <code>Span</code>
	278	* to include <code>otherSpan</code> without
	279	* altering this span's starting position.
	280	* If <code>otherSpan</code> can be so consumed
	281	* by this <code>Span</code> then <code>true</code>
	282	* is returned.
	283	*/
	284	boolean subsume(Span otherSpan) {
	285
	286	/* We can only subsume 'otherSpan' if
	287	* its starting position lies in our
	288	* interval.
	289	*/
	290	boolean isSubsumed = contains(otherSpan.mStart);
	291
	292	/* If the other span's starting position
	293	* was in our interval and the other span
	294	* was longer than this span, then we need
	295	* to grow this span to cover the difference.
	296	*/
	297	if (isSubsumed && otherSpan.mEnd > mEnd) {
	298	mEnd = otherSpan.mEnd;
	299	}
	300
	301	return isSubsumed;
	302	}
	303
	304	/**
	305	* Return true if the passed in position
	306	* lies in the half-open interval defined
	307	* by this <code>Span</code>.
	308	*/
	309	boolean contains(float pos) {
	310	return mStart <= pos && pos < mEnd;
	311	}
	312
	313	/**
	314	* Rank spans according to their starting
	315	* position. The end position is ignored
	316	* in this ranking.
	317	*/
	318	public int compareTo(Object o) {
	319	Span otherSpan = (Span) o;
	320	float otherStart = otherSpan.getStart();
	321	int result;
	322
	323	if (mStart < otherStart) {
	324	result = -1;
	325	} else if (mStart > otherStart) {
	326	result = 1;
	327	} else {
	328	result = 0;
	329	}
	330
	331	return result;
	332	}
	333
	334	public String toString() {
	335	return "Span: " + mStart + " to " + mEnd;
	336	}
	337
	338	}
	339
	340	/**
	341	* This class ranks a pair of <code>Span</code>
	342	* instances. If the instances intersect they
	343	* are deemed equal otherwise they are ranked
	344	* by their relative position. Use
	345	* <code>SpanIntersection.instance</code> to
	346	* get the single instance of this class.
	347	*/
	348	static class SpanIntersection implements Comparator {
	349
	350	/**
	351	* This class is a Singleton and the following
	352	* is the single instance.
	353	*/
	354	static final SpanIntersection instance =
	355	new SpanIntersection();
	356
	357	/**
	358	* Only this class can create instances of itself.
	359	*/
	360	private SpanIntersection() {
	361
	362	}
	363
	364	public int compare(Object o1, Object o2) {
	365	int result;
	366	Span span1 = (Span) o1;
	367	Span span2 = (Span) o2;
	368
	369	/* Span 1 is entirely to the left of span2.
	370	* span1: <-----<
	371	* span2: <-----<
	372	*/
	373	if (span1.getEnd() <= span2.getStart()) {
	374	result = -1;
	375
	376	/* Span 2 is entirely to the right of span2.
	377	* span1: <-----<
	378	* span2: <-----<
	379	*/
	380	} else if (span1.getStart() >= span2.getEnd()) {
	381	result = 1;
	382
	383	/* Otherwise they intersect and we declare them equal.
	384	*/
	385	} else {
	386	result = 0;
	387	}
	388
	389	return result;
	390	}
	391
	392	}
	393	}

java/pkg/sun/java2d/StateTrackable$State.class+0−0

Binary file not shown.

java/pkg/sun/java2d/StateTrackable.class+0−0

Binary file not shown.

java/pkg/sun/java2d/StateTrackable.java+256−0

@@ -0,0 +1,256 @@
	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;
	27
	28	/**
	29	* This interface is implemented by classes which contain complex state
	30	* so that other objects can track whether or not their state has changed
	31	* since earlier interactions with the object.
	32	* <p>
	33	* The suggested usage pattern for code that manages some trackable data
	34	* is as follows:
	35	* <pre>
	36	* class Trackable implements StateTrackable {
	37	* TrackedInfo data;
	38	* State curState = STABLE;
	39	* StateTracker curTracker = null;
	40	* // Hypothetical method to return a static piece of our tracked data.
	41	* // Assume that Datum is either a copy of some piece of the tracked
	42	* // data or that it is itself immutable.
	43	* public Datum getSomeDatum(int key) {
	44	* // No need to modify the state for this type of "get" call.
	45	* return data.getDatum(key);
	46	* }
	47	* // Hypothetical method to return a raw reference to our tracked data.
	48	* public TrackedInfo getRawHandleToInfo() {
	49	* // Since we are returning a raw reference to our tracked
	50	* // data and since we can not track what the caller will
	51	* // do with that reference, we can no longer track the
	52	* // state of this data.
	53	* synchronized (this) {
	54	* // Note: modifying both curState and curTracker requires
	55	* // synchronization against the getStateTracker method.
	56	* curState = UNTRACKABLE;
	57	* curTracker = null;
	58	* }
	59	* return data;
	60	* }
	61	* // Hypothetical method to set a single piece of data to some
	62	* // new static value.
	63	* public void setSomeDatum(int key, Datum datum) {
	64	* data.setDatum(key, datum);
	65	* // We do not need to change state for this, we simply
	66	* // invalidate the outstanding StateTracker objects.
	67	* // Note: setting curTracker to null requires no synchronization.
	68	* curTracker = null;
	69	* }
	70	* // getStateTracker must be synchronized against any code that
	71	* // changes the State.
	72	* public synchronized StateTracker getStateTracker() {
	73	* StateTracker st = curTracker;
	74	* if (st == null) {
	75	* switch (curState) {
	76	* case IMMUTABLE: st = StateTracker.ALWAYS_CURRENT; break;
	77	* case STABLE: st = new Tracker(this); break;
	78	* case DYNAMIC: st = StateTracker.NEVER_CURRENT; break;
	79	* case UNTRACKABLE: st = StateTracker.NEVER_CURRENT; break;
	80	* }
	81	* curTracker = st;
	82	* }
	83	* return st;
	84	* }
	85	*
	86	* static class Tracker implements StateTracker {
	87	* Trackable theTrackable;
	88	* public Tracker(Trackable t) {
	89	* theTrackable = t;
	90	* }
	91	* public boolean isCurrent() {
	92	* return (theTrackable.curTracker == this);
	93	* }
	94	* }
	95	* }
	96	* </pre>
	97	* Note that the mechanism shown above for invalidating outstanding
	98	* StateTracker objects is not the most theoretically conservative
	99	* way to implement state tracking in a "set" method.
	100	* There is a small window of opportunity after the data has changed
	101	* before the outstanding StateTracker objects are invalidated and
	102	* where they will indicate that the data is still the same as when
	103	* they were instantiated.
	104	* While this is technically inaccurate, it is acceptable since the more
	105	* conservative approaches to state management are much more complex and
	106	* cost much more in terms of performance for a very small gain in
	107	* correctness.
	108	* For example:
	109	* <p>
	110	* The most conservative approach would be to synchronize all accesses
	111	* and all modifications to the data, including its State.
	112	* This would require synchronized blocks around some potentially large
	113	* bodies of code which would impact the multi-threaded scalability of
	114	* the implementation.
	115	* Further, if data is to be coordinated or transferred between two
	116	* trackable objects then both would need to be synchronized raising
	117	* the possibility of deadlock unless some strict rules of priority
	118	* for the locking of the objects were established and followed
	119	* religiously.
	120	* Either or both of these drawbacks makes such an implementation
	121	* infeasible.
	122	* <p>
	123	* A less conservative approach would be to change the state of the
	124	* trackable object to DYNAMIC during all modifications of the data
	125	* and then to change it back to STABLE after those modifications
	126	* are complete.
	127	* While this state transition more accurately reflects the temporary
	128	* loss of tracking during the modification phase, in reality the
	129	* time period of the modifications would be small in most cases
	130	* and the 2 changes of state would each require synchronization.
	131	* <p>
	132	* In comparison the act of setting the <code>curTracker</code>
	133	* reference to null in the usage pattern above effectively invalidates
	134	* all outstanding <code>Tracker</code> objects as soon as possible
	135	* after the change to the data and requires very little code and no
	136	* synchronization to implement.
	137	* <p>
	138	* In the end it is up to the implementor of a StateTrackable object
	139	* how fine the granularity of State updates should be managed based
	140	* on the frequency and atomicity of the modifications and the
	141	* consequences of returning an inaccurate State for a particularly
	142	* small window of opportunity.
	143	* Most implementations are likely to follow the liberal, but efficient
	144	* guidelines found in the usage pattern proposed above.
	145	*
	146	* @since 1.7
	147	*/
	148	public interface StateTrackable {
	149	/**
	150	* An enumeration describing the current state of a trackable
	151	* object.
	152	* These values describe how often the complex data contained
	153	* in a trackable object can be changed and whether or not it
	154	* makes sense to try to track the data in its current state.
	155	* @see StateTrackable#getState
	156	* @since 1.7
	157	*/
	158	public enum State {
	159	/**
	160	* The complex data will never change again.
	161	* Information related to the current contents of the complex
	162	* data can be calculated and cached indefinitely with no
	163	* further checks to see if the information is stale.
	164	*/
	165	IMMUTABLE,
	166
	167	/**
	168	* The complex data is currently stable, but could change at
	169	* some point in the future.
	170	* Information related to the current contents of the complex
	171	* data can be calculated and cached, but a StateTracker should
	172	* be used to verify the freshness of such precalculated data
	173	* before each future use.
	174	*/
	175	STABLE,
	176
	177	/**
	178	* The complex data is currently in flux and is frequently
	179	* changing.
	180	* While information related to the current contents of the
	181	* complex data could be calculated and cached, there is a
	182	* reasonably high probability that the cached information
	183	* would be found to be out of date by the next time it is
	184	* used.
	185	* It may also be the case that the current contents are
	186	* temporarily untrackable, but that they may become trackable
	187	* again in the future.
	188	*/
	189	DYNAMIC,
	190
	191	/**
	192	* The complex data can currently be changed by external
	193	* references and agents in a way that cannot be tracked.
	194	* If any information about the current contents of the complex
	195	* data were to be cached, there would be no way to determine
	196	* whether or not that cached information was out of date.
	197	*/
	198	UNTRACKABLE,
	199	};
	200
	201	/**
	202	* Returns the general state of the complex data held by this
	203	* object.
	204	* This return value can be used to determine if it makes
	205	* strategic sense to try and cache information about the current
	206	* contents of this object.
	207	* The StateTracker returned from the getStateTracker() method
	208	* will further aid in determining when the data has been
	209	* changed so that the caches can be verified upon future uses.
	210	* @return the current state of trackability of the complex
	211	* data stored in this object.
	212	* @see #getStateTracker
	213	* @since 1.7
	214	*/
	215	public State getState();
	216
	217	/**
	218	* Returns an object which can track future changes to the
	219	* complex data stored in this object.
	220	* If an external agent caches information about the complex
	221	* data of this object, it should first get a StateTracker
	222	* object from this method so that it can check if such
	223	* information is current upon future uses.
	224	* Note that a valid StateTracker will always be returned
	225	* regardless of the return value of getState(), but in some
	226	* cases the StateTracker may be a trivial implementation
	227	* which always returns the same value from its
	228	* {@link StateTracker#isCurrent isCurrent} method.
	229	* <ul>
	230	* <li>If the current state is {@link State#IMMUTABLE IMMUTABLE},
	231	* this StateTracker and any future StateTracker objects
	232	* returned from this method will always indicate that
	233	* the state has not changed.</li>
	234	* <li>If the current state is {@link State#UNTRACKABLE UNTRACKABLE},
	235	* this StateTracker and any future StateTracker objects
	236	* returned from this method will always indicate that
	237	* the state has changed.</li>
	238	* <li>If the current state is {@link State#DYNAMIC DYNAMIC},
	239	* this StateTracker may always indicate that the current
	240	* state has changed, but another StateTracker returned
	241	* from this method in the future when the state has changed
	242	* to {@link State#STABLE STABLE} will correctly track changes.</li>
	243	* <li>Otherwise the current state is {@link State#STABLE STABLE}
	244	* and this StateTracker will indicate whether or not the
	245	* data has changed since the time at which it was fetched
	246	* from the object.</li>
	247	* </ul>
	248	* @return an object implementing the StateTracker interface
	249	* that tracks whether changes have been made to the complex
	250	* contents of this object since it was returned.
	251	* @see State
	252	* @see #getState
	253	* @since 1.7
	254	*/
	255	public StateTracker getStateTracker();
	256	}

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

Binary file not shown.

java/pkg/sun/java2d/StateTrackableDelegate$2.class+0−0

Binary file not shown.

java/pkg/sun/java2d/StateTrackableDelegate.class+0−0

Binary file not shown.

java/pkg/sun/java2d/StateTrackableDelegate.java+256−0

@@ -0,0 +1,256 @@
	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;
	27
	28	import sun.java2d.StateTrackable.State;
	29	import static sun.java2d.StateTrackable.State.*;
	30
	31	/**
	32	* This class provides a basic pre-packaged implementation of the
	33	* complete {@link StateTrackable} interface with implementations
	34	* of the required methods in the interface and methods to manage
	35	* transitions in the state of the object.
	36	* Classes which wish to implement StateTrackable could create an
	37	* instance of this class and delegate all of their implementations
	38	* for {@code StateTrackable} methods to the corresponding methods
	39	* of this class.
	40	*/
	41	public final class StateTrackableDelegate implements StateTrackable {
	42	/**
	43	* The {@code UNTRACKABLE_DELEGATE} provides an implementation
	44	* of the StateTrackable interface that is permanently in the
	45	* {@link State#UNTRACKABLE UNTRACKABLE} state.
	46	*/
	47	public final static StateTrackableDelegate UNTRACKABLE_DELEGATE =
	48	new StateTrackableDelegate(UNTRACKABLE);
	49
	50	/**
	51	* The {@code IMMUTABLE_DELEGATE} provides an implementation
	52	* of the StateTrackable interface that is permanently in the
	53	* {@link State#IMMUTABLE IMMUTABLE} state.
	54	*/
	55	public final static StateTrackableDelegate IMMUTABLE_DELEGATE =
	56	new StateTrackableDelegate(IMMUTABLE);
	57
	58	/**
	59	* Returns a {@code StateTrackableDelegate} instance with the
	60	* specified initial {@link State State}.
	61	* If the specified {@code State} is
	62	* {@link State#UNTRACKABLE UNTRACKABLE} or
	63	* {@link State#IMMUTABLE IMMUTABLE}
	64	* then the approprirate static instance
	65	* {@link #UNTRACKABLE_DELEGATE} or {@link #IMMUTABLE_DELEGATE}
	66	* is returned.
	67	*/
	68	public static StateTrackableDelegate createInstance(State state) {
	69	switch (state) {
	70	case UNTRACKABLE:
	71	return UNTRACKABLE_DELEGATE;
	72	case STABLE:
	73	return new StateTrackableDelegate(STABLE);
	74	case DYNAMIC:
	75	return new StateTrackableDelegate(DYNAMIC);
	76	case IMMUTABLE:
	77	return IMMUTABLE_DELEGATE;
	78	default:
	79	throw new InternalError("unknown state");
	80	}
	81	}
	82
	83	private State theState;
	84	StateTracker theTracker; // package private for easy access from tracker
	85	private int numDynamicAgents;
	86
	87	/**
	88	* Constructs a StateTrackableDelegate object with the specified
	89	* initial State.
	90	*/
	91	private StateTrackableDelegate(State state) {
	92	this.theState = state;
	93	}
	94
	95	/**
	96	* @inheritDoc
	97	* @since 1.7
	98	*/
	99	public State getState() {
	100	return theState;
	101	}
	102
	103	/**
	104	* @inheritDoc
	105	* @since 1.7
	106	*/
	107	public synchronized StateTracker getStateTracker() {
	108	StateTracker st = theTracker;
	109	if (st == null) {
	110	switch (theState) {
	111	case IMMUTABLE:
	112	st = StateTracker.ALWAYS_CURRENT;
	113	break;
	114	case STABLE:
	115	st = new StateTracker() {
	116	public boolean isCurrent() {
	117	return (theTracker == this);
	118	}
	119	};
	120	break;
	121	case DYNAMIC:
	122	// We return the NEVER_CURRENT tracker, but that is
	123	// just temporary while we are in the DYNAMIC state.
	124	// NO BREAK
	125	case UNTRACKABLE:
	126	st = StateTracker.NEVER_CURRENT;
	127	break;
	128	}
	129	theTracker = st;
	130	}
	131	return st;
	132	}
	133
	134	/**
	135	* This method provides an easy way for delegating classes to
	136	* change the overall {@link State State} of the delegate to
	137	* {@link State#IMMUTABLE IMMUTABLE}.
	138	* @throws IllegalStateException if the current state is
	139	* {@link State#UNTRACKABLE UNTRACKABLE}
	140	* @see #setUntrackable
	141	* @since 1.7
	142	*/
	143	public synchronized void setImmutable() {
	144	if (theState == UNTRACKABLE \|\| theState == DYNAMIC) {
	145	throw new IllegalStateException("UNTRACKABLE or DYNAMIC "+
	146	"objects cannot become IMMUTABLE");
	147	}
	148	theState = IMMUTABLE;
	149	theTracker = null;
	150	}
	151
	152	/**
	153	* This method provides an easy way for delegating classes to
	154	* change the overall {@link State State} of the delegate to
	155	* {@link State#UNTRACKABLE UNTRACKABLE}.
	156	* This method is typically called when references to the
	157	* internal data buffers have been made public.
	158	* @throws IllegalStateException if the current state is
	159	* {@link State#IMMUTABLE IMMUTABLE}
	160	* @see #setImmutable
	161	* @since 1.7
	162	*/
	163	public synchronized void setUntrackable() {
	164	if (theState == IMMUTABLE) {
	165	throw new IllegalStateException("IMMUTABLE objects cannot "+
	166	"become UNTRACKABLE");
	167	}
	168	theState = UNTRACKABLE;
	169	theTracker = null;
	170	}
	171
	172	/**
	173	* This method provides an easy way for delegating classes to
	174	* manage temporarily setting the overall {@link State State}
	175	* of the delegate to {@link State#DYNAMIC DYNAMIC}
	176	* during well-defined time frames of dynamic pixel updating.
	177	* This method should be called once before each flow of control
	178	* that might dynamically update the pixels in an uncontrolled
	179	* or unpredictable fashion.
	180	* <p>
	181	* The companion method {@link #removeDynamicAgent} method should
	182	* also be called once after each such flow of control has ended.
	183	* Failing to call the remove method will result in this object
	184	* permanently becoming {@link State#DYNAMIC DYNAMIC}
	185	* and therefore effectively untrackable.
	186	* <p>
	187	* This method will only change the {@link State State} of the
	188	* delegate if it is currently {@link State#STABLE STABLE}.
	189	*
	190	* @throws IllegalStateException if the current state is
	191	* {@link State#IMMUTABLE IMMUTABLE}
	192	* @since 1.7
	193	*/
	194	public synchronized void addDynamicAgent() {
	195	if (theState == IMMUTABLE) {
	196	throw new IllegalStateException("Cannot change state from "+
	197	"IMMUTABLE");
	198	}
	199	++numDynamicAgents;
	200	if (theState == STABLE) {
	201	theState = DYNAMIC;
	202	theTracker = null;
	203	}
	204	}
	205
	206	/**
	207	* This method provides an easy way for delegating classes to
	208	* manage restoring the overall {@link State State} of the
	209	* delegate back to {@link State#STABLE STABLE}
	210	* after a well-defined time frame of dynamic pixel updating.
	211	* This method should be called once after each flow of control
	212	* that might dynamically update the pixels in an uncontrolled
	213	* or unpredictable fashion has ended.
	214	* <p>
	215	* The companion method {@link #addDynamicAgent} method should
	216	* have been called at some point before each such flow of
	217	* control began.
	218	* If this method is called without having previously called
	219	* the add method, the {@link State State} of this object
	220	* will become unreliable.
	221	* <p>
	222	* This method will only change the {@link State State} of the
	223	* delegate if the number of outstanding dynamic agents has
	224	* gone to 0 and it is currently
	225	* {@link State#DYNAMIC DYNAMIC}.
	226	*
	227	* @since 1.7
	228	*/
	229	protected synchronized void removeDynamicAgent() {
	230	if (--numDynamicAgents == 0 && theState == DYNAMIC) {
	231	theState = STABLE;
	232	theTracker = null;
	233	}
	234	}
	235
	236	/**
	237	* This method provides an easy way for delegating classes to
	238	* indicate that the contents have changed.
	239	* This method will invalidate outstanding StateTracker objects
	240	* so that any other agents which maintain cached information
	241	* about the pixels will know to refresh their cached copies.
	242	* This method should be called after every modification to
	243	* the data, such as any calls to any of the setElem methods.
	244	* <p>
	245	* Note that, for efficiency, this method does not check the
	246	* {@link State State} of the object to see if it is compatible
	247	* with being marked dirty
	248	* (i.e. not {@link State#IMMUTABLE IMMUTABLE}).
	249	* It is up to the callers to enforce the fact that an
	250	* {@code IMMUTABLE} delegate is never modified.
	251	* @since 1.7
	252	*/
	253	public final void markDirty() {
	254	theTracker = null;
	255	}
	256	}

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

Binary file not shown.

java/pkg/sun/java2d/StateTracker$2.class+0−0

Binary file not shown.

java/pkg/sun/java2d/StateTracker.class+0−0

Binary file not shown.

java/pkg/sun/java2d/StateTracker.java+104−0

@@ -0,0 +1,104 @@
	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;
	27
	28	/**
	29	* This interface is used to track changes to the complex data of an
	30	* object that implements the StateTrackable interface.
	31	* <p>
	32	* The usage pattern for code accessing the trackable data is as follows:
	33	* <pre>
	34	* StateTrackable trackedobject;
	35	* MyInfo cacheddata;
	36	* StateTracker cachetracker;
	37	* public synchronized MyInfo getInfoAbout(StateTrackable obj) {
	38	* if (trackedobject != obj \|\| !cachetracker.isCurrent()) {
	39	* // Note: Always call getStateTracker() before
	40	* // caching any data about the objct...
	41	* cachetracker = obj.getStateTracker();
	42	* cacheddata = calculateInfoFrom(obj);
	43	* trackedobject = obj;
	44	* }
	45	* return cacheddata;
	46	* }
	47	* </pre>
	48	* Note that the sample code above works correctly regardless of the
	49	* {@link StateTrackable.State State} of the complex data of the object,
	50	* but it may be inefficient to store precalculated information about
	51	* an object whose current {@link StateTrackable.State State} is
	52	* {@link StateTrackable.State#UNTRACKABLE UNTRACKABLE}
	53	* and it is unnecessary to perform the {@link #isCurrent} test for
	54	* data whose current {@link StateTrackable.State State} is
	55	* {@link StateTrackable.State#IMMUTABLE IMMUTABLE}.
	56	* Optimizations to the sample code for either or both of those terminal
	57	* States may be of benefit for some use cases, but is left out of the
	58	* example to reduce its complexity.
	59	*
	60	* @see StateTrackable.State
	61	* @since 1.7
	62	*/
	63	public interface StateTracker {
	64	/**
	65	* An implementation of the StateTracker interface which
	66	* always returns true.
	67	* This implementation is useful for objects whose current
	68	* {@link StateTrackable.State State} is
	69	* {@link StateTrackable.State#IMMUTABLE IMMUTABLE}.
	70	* @since 1.7
	71	*/
	72	public StateTracker ALWAYS_CURRENT = new StateTracker() {
	73	public boolean isCurrent() {
	74	return true;
	75	}
	76	};
	77
	78	/**
	79	* An implementation of the StateTracker interface which
	80	* always returns false.
	81	* This implementation is useful for objects whose current
	82	* {@link StateTrackable.State State} is
	83	* {@link StateTrackable.State#UNTRACKABLE UNTRACKABLE}.
	84	* This implementation may also be useful for some objects
	85	* whose current {@link StateTrackable.State State} is
	86	* {@link StateTrackable.State#DYNAMIC DYNAMIC}.
	87	* @since 1.7
	88	*/
	89	public StateTracker NEVER_CURRENT = new StateTracker() {
	90	public boolean isCurrent() {
	91	return false;
	92	}
	93	};
	94
	95	/**
	96	* Returns true iff the contents of the complex data of the
	97	* associated StateTrackable object have not changed since
	98	* the time that this StateTracker was returned from its
	99	* getStateTracker() method.
	100	* @see StateTrackable
	101	* @since 1.7
	102	*/
	103	public boolean isCurrent();
	104	}

java/pkg/sun/java2d/SunCompositeContext.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SunCompositeContext.java+129−0

@@ -0,0 +1,129 @@
	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;
	27
	28	import java.awt.Composite;
	29	import java.awt.CompositeContext;
	30	import java.awt.AlphaComposite;
	31	import java.awt.image.ColorModel;
	32	import java.awt.image.BufferedImage;
	33	import java.awt.image.Raster;
	34	import java.awt.image.WritableRaster;
	35	import sun.awt.image.BufImgSurfaceData;
	36	import sun.java2d.loops.XORComposite;
	37	import sun.java2d.loops.CompositeType;
	38	import sun.java2d.loops.Blit;
	39
	40	public class SunCompositeContext implements CompositeContext {
	41	ColorModel srcCM;
	42	ColorModel dstCM;
	43	Composite composite;
	44	CompositeType comptype;
	45
	46	public SunCompositeContext(AlphaComposite ac,
	47	ColorModel s, ColorModel d)
	48	{
	49	if (s == null) {
	50	throw new NullPointerException("Source color model cannot be null");
	51	}
	52	if (d == null) {
	53	throw new NullPointerException("Destination color model cannot be null");
	54	}
	55	srcCM = s;
	56	dstCM = d;
	57	this.composite = ac;
	58	this.comptype = CompositeType.forAlphaComposite(ac);
	59	}
	60
	61	public SunCompositeContext(XORComposite xc,
	62	ColorModel s, ColorModel d)
	63	{
	64	if (s == null) {
	65	throw new NullPointerException("Source color model cannot be null");
	66	}
	67	if (d == null) {
	68	throw new NullPointerException("Destination color model cannot be null");
	69	}
	70	srcCM = s;
	71	dstCM = d;
	72	this.composite = xc;
	73	this.comptype = CompositeType.Xor;
	74	}
	75
	76	/**
	77	* Release resources allocated for context.
	78	*/
	79	public void dispose() {
	80	}
	81
	82	/**
	83	* This method composes the two source tiles
	84	* and places the result in the destination tile. Note that
	85	* the destination can be the same object as either
	86	* the first or second source.
	87	* @param src1 The first source tile for the compositing operation.
	88	* @param src2 The second source tile for the compositing operation.
	89	* @param dst The tile where the result of the operation is stored.
	90	*/
	91	public void compose(Raster srcArg, Raster dstIn, WritableRaster dstOut) {
	92	WritableRaster src;
	93	int w;
	94	int h;
	95
	96	if (dstIn != dstOut) {
	97	dstOut.setDataElements(0, 0, dstIn);
	98	}
	99
	100	// REMIND: We should be able to create a SurfaceData from just
	101	// a non-writable Raster and a ColorModel. Since we need to
	102	// create a SurfaceData from a BufferedImage then we need to
	103	// make a WritableRaster since it is needed to construct a
	104	// BufferedImage.
	105	if (srcArg instanceof WritableRaster) {
	106	src = (WritableRaster) srcArg;
	107	} else {
	108	src = srcArg.createCompatibleWritableRaster();
	109	src.setDataElements(0, 0, srcArg);
	110	}
	111
	112	w = Math.min(src.getWidth(), dstIn.getWidth());
	113	h = Math.min(src.getHeight(), dstIn.getHeight());
	114
	115	BufferedImage srcImg = new BufferedImage(srcCM, src,
	116	srcCM.isAlphaPremultiplied(),
	117	null);
	118	BufferedImage dstImg = new BufferedImage(dstCM, dstOut,
	119	dstCM.isAlphaPremultiplied(),
	120	null);
	121
	122	SurfaceData srcData = BufImgSurfaceData.createData(srcImg);
	123	SurfaceData dstData = BufImgSurfaceData.createData(dstImg);
	124	Blit blit = Blit.getFromCache(srcData.getSurfaceType(),
	125	comptype,
	126	dstData.getSurfaceType());
	127	blit.Blit(srcData, dstData, composite, null, 0, 0, 0, 0, w, h);
	128	}
	129	}

java/pkg/sun/java2d/SunGraphics2D.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SunGraphics2D.java+3310−0

@@ -0,0 +1,3310 @@
	1	/*
	2	* Copyright (c) 1996, 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;
	27
	28	import java.awt.Graphics;
	29	import java.awt.Graphics2D;
	30	import java.awt.RenderingHints;
	31	import java.awt.RenderingHints.Key;
	32	import java.awt.geom.Area;
	33	import java.awt.geom.AffineTransform;
	34	import java.awt.geom.NoninvertibleTransformException;
	35	import java.awt.AlphaComposite;
	36	import java.awt.BasicStroke;
	37	import java.awt.image.BufferedImage;
	38	import java.awt.image.BufferedImageOp;
	39	import java.awt.image.RenderedImage;
	40	import java.awt.image.renderable.RenderableImage;
	41	import java.awt.image.renderable.RenderContext;
	42	import java.awt.image.AffineTransformOp;
	43	import java.awt.image.Raster;
	44	import java.awt.image.WritableRaster;
	45	import java.awt.Image;
	46	import java.awt.Composite;
	47	import java.awt.Color;
	48	import java.awt.image.ColorModel;
	49	import java.awt.GraphicsConfiguration;
	50	import java.awt.Paint;
	51	import java.awt.GradientPaint;
	52	import java.awt.LinearGradientPaint;
	53	import java.awt.RadialGradientPaint;
	54	import java.awt.TexturePaint;
	55	import java.awt.geom.Rectangle2D;
	56	import java.awt.geom.PathIterator;
	57	import java.awt.geom.GeneralPath;
	58	import java.awt.Shape;
	59	import java.awt.Stroke;
	60	import java.awt.FontMetrics;
	61	import java.awt.Rectangle;
	62	import java.text.AttributedCharacterIterator;
	63	import java.awt.Font;
	64	import java.awt.image.ImageObserver;
	65	import java.awt.Transparency;
	66	import java.awt.font.GlyphVector;
	67	import java.awt.font.TextLayout;
	68	import sun.font.FontDesignMetrics;
	69	import sun.font.FontUtilities;
	70	import sun.java2d.pipe.PixelDrawPipe;
	71	import sun.java2d.pipe.PixelFillPipe;
	72	import sun.java2d.pipe.ShapeDrawPipe;
	73	import sun.java2d.pipe.ValidatePipe;
	74	import sun.java2d.pipe.ShapeSpanIterator;
	75	import sun.java2d.pipe.Region;
	76	import sun.java2d.pipe.TextPipe;
	77	import sun.java2d.pipe.DrawImagePipe;
	78	import sun.java2d.pipe.LoopPipe;
	79	import sun.java2d.loops.FontInfo;
	80	import sun.java2d.loops.RenderLoops;
	81	import sun.java2d.loops.CompositeType;
	82	import sun.java2d.loops.SurfaceType;
	83	import sun.java2d.loops.Blit;
	84	import sun.java2d.loops.MaskFill;
	85	import sun.font.FontManager;
	86	import java.awt.font.FontRenderContext;
	87	import sun.java2d.loops.XORComposite;
	88	import sun.awt.ConstrainableGraphics;
	89	import sun.awt.SunHints;
	90	import java.util.Map;
	91	import java.util.Iterator;
	92	import sun.java2d.DestSurfaceProvider;
	93	import sun.misc.PerformanceLogger;
	94
	95	/**
	96	* This is a the master Graphics2D superclass for all of the Sun
	97	* Graphics implementations. This class relies on subclasses to
	98	* manage the various device information, but provides an overall
	99	* general framework for performing all of the requests in the
	100	* Graphics and Graphics2D APIs.
	101	*
	102	* @author Jim Graham
	103	*/
	104	public final class SunGraphics2D
	105	extends Graphics2D
	106	implements ConstrainableGraphics, Cloneable, DestSurfaceProvider
	107	{
	108	/*
	109	* Attribute States
	110	*/
	111	/* Paint */
	112	public static final int PAINT_CUSTOM = 6; /* Any other Paint object */
	113	public static final int PAINT_TEXTURE = 5; /* Tiled Image */
	114	public static final int PAINT_RAD_GRADIENT = 4; /* Color RadialGradient */
	115	public static final int PAINT_LIN_GRADIENT = 3; /* Color LinearGradient */
	116	public static final int PAINT_GRADIENT = 2; /* Color Gradient */
	117	public static final int PAINT_ALPHACOLOR = 1; /* Non-opaque Color */
	118	public static final int PAINT_OPAQUECOLOR = 0; /* Opaque Color */
	119
	120	/* Composite*/
	121	public static final int COMP_CUSTOM = 3;/* Custom Composite */
	122	public static final int COMP_XOR = 2;/* XOR Mode Composite */
	123	public static final int COMP_ALPHA = 1;/* AlphaComposite */
	124	public static final int COMP_ISCOPY = 0;/* simple stores into destination,
	125	* i.e. Src, SrcOverNoEa, and other
	126	* alpha modes which replace
	127	* the destination.
	128	*/
	129
	130	/* Stroke */
	131	public static final int STROKE_CUSTOM = 3; /* custom Stroke */
	132	public static final int STROKE_WIDE = 2; /* BasicStroke */
	133	public static final int STROKE_THINDASHED = 1; /* BasicStroke */
	134	public static final int STROKE_THIN = 0; /* BasicStroke */
	135
	136	/* Transform */
	137	public static final int TRANSFORM_GENERIC = 4; /* any 3x2 */
	138	public static final int TRANSFORM_TRANSLATESCALE = 3; /* scale XY */
	139	public static final int TRANSFORM_ANY_TRANSLATE = 2; /* non-int translate */
	140	public static final int TRANSFORM_INT_TRANSLATE = 1; /* int translate */
	141	public static final int TRANSFORM_ISIDENT = 0; /* Identity */
	142
	143	/* Clipping */
	144	public static final int CLIP_SHAPE = 2; /* arbitrary clip */
	145	public static final int CLIP_RECTANGULAR = 1; /* rectangular clip */
	146	public static final int CLIP_DEVICE = 0; /* no clipping set */
	147
	148	/* The following fields are used when the current Paint is a Color. */
	149	public int eargb; // ARGB value with ExtraAlpha baked in
	150	public int pixel; // pixel value for eargb
	151
	152	public SurfaceData surfaceData;
	153
	154	public PixelDrawPipe drawpipe;
	155	public PixelFillPipe fillpipe;
	156	public DrawImagePipe imagepipe;
	157	public ShapeDrawPipe shapepipe;
	158	public TextPipe textpipe;
	159	public MaskFill alphafill;
	160
	161	public RenderLoops loops;
	162
	163	public CompositeType imageComp; /* Image Transparency checked on fly */
	164
	165	public int paintState;
	166	public int compositeState;
	167	public int strokeState;
	168	public int transformState;
	169	public int clipState;
	170
	171	public Color foregroundColor;
	172	public Color backgroundColor;
	173
	174	public AffineTransform transform;
	175	public int transX;
	176	public int transY;
	177
	178	protected static final Stroke defaultStroke = new BasicStroke();
	179	protected static final Composite defaultComposite = AlphaComposite.SrcOver;
	180	private static final Font defaultFont =
	181	new Font(Font.DIALOG, Font.PLAIN, 12);
	182
	183	public Paint paint;
	184	public Stroke stroke;
	185	public Composite composite;
	186	protected Font font;
	187	protected FontMetrics fontMetrics;
	188
	189	public int renderHint;
	190	public int antialiasHint;
	191	public int textAntialiasHint;
	192	private int fractionalMetricsHint;
	193
	194	/* A gamma adjustment to the colour used in lcd text blitting */
	195	public int lcdTextContrast;
	196	private static int lcdTextContrastDefaultValue = 140;
	197
	198	private int interpolationHint; // raw value of rendering Hint
	199	public int strokeHint;
	200
	201	public int interpolationType; // algorithm choice based on
	202	// interpolation and render Hints
	203
	204	public RenderingHints hints;
	205
	206	public Region constrainClip; // lightweight bounds
	207	public int constrainX;
	208	public int constrainY;
	209
	210	public Region clipRegion;
	211	public Shape usrClip;
	212	protected Region devClip; // Actual physical drawable
	213
	214	// cached state for text rendering
	215	private boolean validFontInfo;
	216	private FontInfo fontInfo;
	217	private FontInfo glyphVectorFontInfo;
	218	private FontRenderContext glyphVectorFRC;
	219
	220	private final static int slowTextTransformMask =
	221	AffineTransform.TYPE_GENERAL_TRANSFORM
	222	\| AffineTransform.TYPE_MASK_ROTATION
	223	\| AffineTransform.TYPE_FLIP;
	224
	225	static {
	226	if (PerformanceLogger.loggingEnabled()) {
	227	PerformanceLogger.setTime("SunGraphics2D static initialization");
	228	}
	229	}
	230
	231	public SunGraphics2D(SurfaceData sd, Color fg, Color bg, Font f) {
	232	surfaceData = sd;
	233	foregroundColor = fg;
	234	backgroundColor = bg;
	235
	236	transform = new AffineTransform();
	237	stroke = defaultStroke;
	238	composite = defaultComposite;
	239	paint = foregroundColor;
	240
	241	imageComp = CompositeType.SrcOverNoEa;
	242
	243	renderHint = SunHints.INTVAL_RENDER_DEFAULT;
	244	antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
	245	textAntialiasHint = SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT;
	246	fractionalMetricsHint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
	247	lcdTextContrast = lcdTextContrastDefaultValue;
	248	interpolationHint = -1;
	249	strokeHint = SunHints.INTVAL_STROKE_DEFAULT;
	250
	251	interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
	252
	253	validateColor();
	254
	255	font = f;
	256	if (font == null) {
	257	font = defaultFont;
	258	}
	259
	260	setDevClip(sd.getBounds());
	261	invalidatePipe();
	262	}
	263
	264	protected Object clone() {
	265	try {
	266	SunGraphics2D g = (SunGraphics2D) super.clone();
	267	g.transform = new AffineTransform(this.transform);
	268	if (hints != null) {
	269	g.hints = (RenderingHints) this.hints.clone();
	270	}
	271	/* FontInfos are re-used, so must be cloned too, if they
	272	* are valid, and be nulled out if invalid.
	273	* The implied trade-off is that there is more to be gained
	274	* from re-using these objects than is lost by having to
	275	* clone them when the SG2D is cloned.
	276	*/
	277	if (this.fontInfo != null) {
	278	if (this.validFontInfo) {
	279	g.fontInfo = (FontInfo)this.fontInfo.clone();
	280	} else {
	281	g.fontInfo = null;
	282	}
	283	}
	284	if (this.glyphVectorFontInfo != null) {
	285	g.glyphVectorFontInfo =
	286	(FontInfo)this.glyphVectorFontInfo.clone();
	287	g.glyphVectorFRC = this.glyphVectorFRC;
	288	}
	289	//g.invalidatePipe();
	290	return g;
	291	} catch (CloneNotSupportedException e) {
	292	}
	293	return null;
	294	}
	295
	296	/**
	297	* Create a new SunGraphics2D based on this one.
	298	*/
	299	public Graphics create() {
	300	return (Graphics) clone();
	301	}
	302
	303	public void setDevClip(int x, int y, int w, int h) {
	304	Region c = constrainClip;
	305	if (c == null) {
	306	devClip = Region.getInstanceXYWH(x, y, w, h);
	307	} else {
	308	devClip = c.getIntersectionXYWH(x, y, w, h);
	309	}
	310	validateCompClip();
	311	}
	312
	313	public void setDevClip(Rectangle r) {
	314	setDevClip(r.x, r.y, r.width, r.height);
	315	}
	316
	317	/**
	318	* Constrain rendering for lightweight objects.
	319	*
	320	* REMIND: This method will back off to the "workaround"
	321	* of using translate and clipRect if the Graphics
	322	* to be constrained has a complex transform. The
	323	* drawback of the workaround is that the resulting
	324	* clip and device origin cannot be "enforced".
	325	*
	326	* @exception IllegalStateException If the Graphics
	327	* to be constrained has a complex transform.
	328	*/
	329	public void constrain(int x, int y, int w, int h) {
	330	if ((x\|y) != 0) {
	331	translate(x, y);
	332	}
	333	if (transformState >= TRANSFORM_TRANSLATESCALE) {
	334	clipRect(0, 0, w, h);
	335	return;
	336	}
	337	x = constrainX = transX;
	338	y = constrainY = transY;
	339	w = Region.dimAdd(x, w);
	340	h = Region.dimAdd(y, h);
	341	Region c = constrainClip;
	342	if (c == null) {
	343	c = Region.getInstanceXYXY(x, y, w, h);
	344	} else {
	345	c = c.getIntersectionXYXY(x, y, w, h);
	346	if (c == constrainClip) {
	347	// Common case to ignore
	348	return;
	349	}
	350	}
	351	constrainClip = c;
	352	if (!devClip.isInsideQuickCheck(c)) {
	353	devClip = devClip.getIntersection(c);
	354	validateCompClip();
	355	}
	356	}
	357
	358	protected static ValidatePipe invalidpipe = new ValidatePipe();
	359
	360	/*
	361	* Invalidate the pipeline
	362	*/
	363	protected void invalidatePipe() {
	364	drawpipe = invalidpipe;
	365	fillpipe = invalidpipe;
	366	shapepipe = invalidpipe;
	367	textpipe = invalidpipe;
	368	imagepipe = invalidpipe;
	369	loops = null;
	370	}
	371
	372	public void validatePipe() {
	373	surfaceData.validatePipe(this);
	374	}
	375
	376	/*
	377	* Intersect two Shapes by the simplest method, attempting to produce
	378	* a simplified result.
	379	* The boolean arguments keep1 and keep2 specify whether or not
	380	* the first or second shapes can be modified during the operation
	381	* or whether that shape must be "kept" unmodified.
	382	*/
	383	Shape intersectShapes(Shape s1, Shape s2, boolean keep1, boolean keep2) {
	384	if (s1 instanceof Rectangle && s2 instanceof Rectangle) {
	385	return ((Rectangle) s1).intersection((Rectangle) s2);
	386	}
	387	if (s1 instanceof Rectangle2D) {
	388	return intersectRectShape((Rectangle2D) s1, s2, keep1, keep2);
	389	} else if (s2 instanceof Rectangle2D) {
	390	return intersectRectShape((Rectangle2D) s2, s1, keep2, keep1);
	391	}
	392	return intersectByArea(s1, s2, keep1, keep2);
	393	}
	394
	395	/*
	396	* Intersect a Rectangle with a Shape by the simplest method,
	397	* attempting to produce a simplified result.
	398	* The boolean arguments keep1 and keep2 specify whether or not
	399	* the first or second shapes can be modified during the operation
	400	* or whether that shape must be "kept" unmodified.
	401	*/
	402	Shape intersectRectShape(Rectangle2D r, Shape s,
	403	boolean keep1, boolean keep2) {
	404	if (s instanceof Rectangle2D) {
	405	Rectangle2D r2 = (Rectangle2D) s;
	406	Rectangle2D outrect;
	407	if (!keep1) {
	408	outrect = r;
	409	} else if (!keep2) {
	410	outrect = r2;
	411	} else {
	412	outrect = new Rectangle2D.Float();
	413	}
	414	double x1 = Math.max(r.getX(), r2.getX());
	415	double x2 = Math.min(r.getX() + r.getWidth(),
	416	r2.getX() + r2.getWidth());
	417	double y1 = Math.max(r.getY(), r2.getY());
	418	double y2 = Math.min(r.getY() + r.getHeight(),
	419	r2.getY() + r2.getHeight());
	420
	421	if (((x2 - x1) < 0) \|\| ((y2 - y1) < 0))
	422	// Width or height is negative. No intersection.
	423	outrect.setFrameFromDiagonal(0, 0, 0, 0);
	424	else
	425	outrect.setFrameFromDiagonal(x1, y1, x2, y2);
	426	return outrect;
	427	}
	428	if (r.contains(s.getBounds2D())) {
	429	if (keep2) {
	430	s = cloneShape(s);
	431	}
	432	return s;
	433	}
	434	return intersectByArea(r, s, keep1, keep2);
	435	}
	436
	437	protected static Shape cloneShape(Shape s) {
	438	return new GeneralPath(s);
	439	}
	440
	441	/*
	442	* Intersect two Shapes using the Area class. Presumably other
	443	* attempts at simpler intersection methods proved fruitless.
	444	* The boolean arguments keep1 and keep2 specify whether or not
	445	* the first or second shapes can be modified during the operation
	446	* or whether that shape must be "kept" unmodified.
	447	* @see #intersectShapes
	448	* @see #intersectRectShape
	449	*/
	450	Shape intersectByArea(Shape s1, Shape s2, boolean keep1, boolean keep2) {
	451	Area a1, a2;
	452
	453	// First see if we can find an overwriteable source shape
	454	// to use as our destination area to avoid duplication.
	455	if (!keep1 && (s1 instanceof Area)) {
	456	a1 = (Area) s1;
	457	} else if (!keep2 && (s2 instanceof Area)) {
	458	a1 = (Area) s2;
	459	s2 = s1;
	460	} else {
	461	a1 = new Area(s1);
	462	}
	463
	464	if (s2 instanceof Area) {
	465	a2 = (Area) s2;
	466	} else {
	467	a2 = new Area(s2);
	468	}
	469
	470	a1.intersect(a2);
	471	if (a1.isRectangular()) {
	472	return a1.getBounds();
	473	}
	474
	475	return a1;
	476	}
	477
	478	/*
	479	* Intersect usrClip bounds and device bounds to determine the composite
	480	* rendering boundaries.
	481	*/
	482	public Region getCompClip() {
	483	if (!surfaceData.isValid()) {
	484	// revalidateAll() implicitly recalculcates the composite clip
	485	revalidateAll();
	486	}
	487
	488	return clipRegion;
	489	}
	490
	491	public Font getFont() {
	492	if (font == null) {
	493	font = defaultFont;
	494	}
	495	return font;
	496	}
	497
	498	private static final double[] IDENT_MATRIX = {1, 0, 0, 1};
	499	private static final AffineTransform IDENT_ATX =
	500	new AffineTransform();
	501
	502	private static final int MINALLOCATED = 8;
	503	private static final int TEXTARRSIZE = 17;
	504	private static double[][] textTxArr = new double[TEXTARRSIZE][];
	505	private static AffineTransform[] textAtArr =
	506	new AffineTransform[TEXTARRSIZE];
	507
	508	static {
	509	for (int i=MINALLOCATED;i<TEXTARRSIZE;i++) {
	510	textTxArr[i] = new double [] {i, 0, 0, i};
	511	textAtArr[i] = new AffineTransform( textTxArr[i]);
	512	}
	513	}
	514
	515	// cached state for various draw[String,Char,Byte] optimizations
	516	public FontInfo checkFontInfo(FontInfo info, Font font,
	517	FontRenderContext frc) {
	518	/* Do not create a FontInfo object as part of construction of an
	519	* SG2D as its possible it may never be needed - ie if no text
	520	* is drawn using this SG2D.
	521	*/
	522	if (info == null) {
	523	info = new FontInfo();
	524	}
	525
	526	float ptSize = font.getSize2D();
	527	int txFontType;
	528	AffineTransform devAt, textAt=null;
	529	if (font.isTransformed()) {
	530	textAt = font.getTransform();
	531	textAt.scale(ptSize, ptSize);
	532	txFontType = textAt.getType();
	533	info.originX = (float)textAt.getTranslateX();
	534	info.originY = (float)textAt.getTranslateY();
	535	textAt.translate(-info.originX, -info.originY);
	536	if (transformState >= TRANSFORM_TRANSLATESCALE) {
	537	transform.getMatrix(info.devTx = new double[4]);
	538	devAt = new AffineTransform(info.devTx);
	539	textAt.preConcatenate(devAt);
	540	} else {
	541	info.devTx = IDENT_MATRIX;
	542	devAt = IDENT_ATX;
	543	}
	544	textAt.getMatrix(info.glyphTx = new double[4]);
	545	double shearx = textAt.getShearX();
	546	double scaley = textAt.getScaleY();
	547	if (shearx != 0) {
	548	scaley = Math.sqrt(shearx * shearx + scaley * scaley);
	549	}
	550	info.pixelHeight = (int)(Math.abs(scaley)+0.5);
	551	} else {
	552	txFontType = AffineTransform.TYPE_IDENTITY;
	553	info.originX = info.originY = 0;
	554	if (transformState >= TRANSFORM_TRANSLATESCALE) {
	555	transform.getMatrix(info.devTx = new double[4]);
	556	devAt = new AffineTransform(info.devTx);
	557	info.glyphTx = new double[4];
	558	for (int i = 0; i < 4; i++) {
	559	info.glyphTx[i] = info.devTx[i] * ptSize;
	560	}
	561	textAt = new AffineTransform(info.glyphTx);
	562	double shearx = transform.getShearX();
	563	double scaley = transform.getScaleY();
	564	if (shearx != 0) {
	565	scaley = Math.sqrt(shearx * shearx + scaley * scaley);
	566	}
	567	info.pixelHeight = (int)(Math.abs(scaley * ptSize)+0.5);
	568	} else {
	569	/* If the double represents a common integral, we
	570	* may have pre-allocated objects.
	571	* A "sparse" array be seems to be as fast as a switch
	572	* even for 3 or 4 pt sizes, and is more flexible.
	573	* This should perform comparably in single-threaded
	574	* rendering to the old code which synchronized on the
	575	* class and scale better on MP systems.
	576	*/
	577	int pszInt = (int)ptSize;
	578	if (ptSize == pszInt &&
	579	pszInt >= MINALLOCATED && pszInt < TEXTARRSIZE) {
	580	info.glyphTx = textTxArr[pszInt];
	581	textAt = textAtArr[pszInt];
	582	info.pixelHeight = pszInt;
	583	} else {
	584	info.pixelHeight = (int)(ptSize+0.5);
	585	}
	586	if (textAt == null) {
	587	info.glyphTx = new double[] {ptSize, 0, 0, ptSize};
	588	textAt = new AffineTransform(info.glyphTx);
	589	}
	590
	591	info.devTx = IDENT_MATRIX;
	592	devAt = IDENT_ATX;
	593	}
	594	}
	595
	596	info.font2D = FontUtilities.getFont2D(font);
	597
	598	int fmhint = fractionalMetricsHint;
	599	if (fmhint == SunHints.INTVAL_FRACTIONALMETRICS_DEFAULT) {
	600	fmhint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
	601	}
	602	info.lcdSubPixPos = false; // conditionally set true in LCD mode.
	603
	604	/* The text anti-aliasing hints that are set by the client need
	605	* to be interpreted for the current state and stored in the
	606	* FontInfo.aahint which is what will actually be used and
	607	* will be one of OFF, ON, LCD_HRGB or LCD_VRGB.
	608	* This is what pipe selection code should typically refer to, not
	609	* textAntialiasHint. This means we are now evaluating the meaning
	610	* of "default" here. Any pipe that really cares about that will
	611	* also need to consult that variable.
	612	* Otherwise these are being used only as args to getStrike,
	613	* and are encapsulated in that object which is part of the
	614	* FontInfo, so we do not need to store them directly as fields
	615	* in the FontInfo object.
	616	* That could change if FontInfo's were more selectively
	617	* revalidated when graphics state changed. Presently this
	618	* method re-evaluates all fields in the fontInfo.
	619	* The strike doesn't need to know the RGB subpixel order. Just
	620	* if its H or V orientation, so if an LCD option is specified we
	621	* always pass in the RGB hint to the strike.
	622	* frc is non-null only if this is a GlyphVector. For reasons
	623	* which are probably a historical mistake the AA hint in a GV
	624	* is honoured when we render, overriding the Graphics setting.
	625	*/
	626	int aahint;
	627	if (frc == null) {
	628	aahint = textAntialiasHint;
	629	} else {
	630	aahint = ((SunHints.Value)frc.getAntiAliasingHint()).getIndex();
	631	}
	632	if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT) {
	633	if (antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
	634	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
	635	} else {
	636	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_OFF;
	637	}
	638	} else {
	639	/* If we are in checkFontInfo because a rendering hint has been
	640	* set then all pipes are revalidated. But we can also
	641	* be here because setFont() has been called when the 'gasp'
	642	* hint is set, as then the font size determines the text pipe.
	643	* See comments in SunGraphics2d.setFont(Font).
	644	*/
	645	if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_GASP) {
	646	if (info.font2D.useAAForPtSize(info.pixelHeight)) {
	647	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
	648	} else {
	649	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_OFF;
	650	}
	651	} else if (aahint >= SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB) {
	652	/* loops for default rendering modes are installed in the SG2D
	653	* constructor. If there are none this will be null.
	654	* Not all compositing modes update the render loops, so
	655	* we also test that this is a mode we know should support
	656	* this. One minor issue is that the loops aren't necessarily
	657	* installed for a new rendering mode until after this
	658	* method is called during pipeline validation. So it is
	659	* theoretically possible that it was set to null for a
	660	* compositing mode, the composite is then set back to Src,
	661	* but the loop is still null when this is called and AA=ON
	662	* is installed instead of an LCD mode.
	663	* However this is done in the right order in SurfaceData.java
	664	* so this is not likely to be a problem - but not
	665	* guaranteed.
	666	*/
	667	if (
	668	!surfaceData.canRenderLCDText(this)
	669	// loops.drawGlyphListLCDLoop == null \|\|
	670	// compositeState > COMP_ISCOPY \|\|
	671	// paintState > PAINT_ALPHACOLOR
	672	) {
	673	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
	674	} else {
	675	info.lcdRGBOrder = true;
	676	/* Collapse these into just HRGB or VRGB.
	677	* Pipe selection code needs only to test for these two.
	678	* Since these both select the same pipe anyway its
	679	* tempting to collapse into one value. But they are
	680	* different strikes (glyph caches) so the distinction
	681	* needs to be made for that purpose.
	682	*/
	683	if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HBGR) {
	684	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB;
	685	info.lcdRGBOrder = false;
	686	} else if
	687	(aahint == SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VBGR) {
	688	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB;
	689	info.lcdRGBOrder = false;
	690	}
	691	/* Support subpixel positioning only for the case in
	692	* which the horizontal resolution is increased
	693	*/
	694	info.lcdSubPixPos =
	695	fmhint == SunHints.INTVAL_FRACTIONALMETRICS_ON &&
	696	aahint == SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB;
	697	}
	698	}
	699	}
	700	info.aaHint = aahint;
	701	info.fontStrike = info.font2D.getStrike(font, devAt, textAt,
	702	aahint, fmhint);
	703	return info;
	704	}
	705
	706	public static boolean isRotated(double [] mtx) {
	707	if ((mtx[0] == mtx[3]) &&
	708	(mtx[1] == 0.0) &&
	709	(mtx[2] == 0.0) &&
	710	(mtx[0] > 0.0))
	711	{
	712	return false;
	713	}
	714
	715	return true;
	716	}
	717
	718	public void setFont(Font font) {
	719	/* replacing the reference equality test font != this.font with
	720	* !font.equals(this.font) did not yield any measurable difference
	721	* in testing, but there may be yet to be identified cases where it
	722	* is beneficial.
	723	*/
	724	if (font != null && font!=this.font/!font.equals(this.font)/) {
	725	/* In the GASP AA case the textpipe depends on the glyph size
	726	* as determined by graphics and font transforms as well as the
	727	* font size, and information in the font. But we may invalidate
	728	* the pipe only to find that it made no difference.
	729	* Deferring pipe invalidation to checkFontInfo won't work because
	730	* when called we may already be rendering to the wrong pipe.
	731	* So, if the font is transformed, or the graphics has more than
	732	* a simple scale, we'll take that as enough of a hint to
	733	* revalidate everything. But if they aren't we will
	734	* use the font's point size to query the gasp table and see if
	735	* what it says matches what's currently being used, in which
	736	* case there's no need to invalidate the textpipe.
	737	* This should be sufficient for all typical uses cases.
	738	*/
	739	if (textAntialiasHint == SunHints.INTVAL_TEXT_ANTIALIAS_GASP &&
	740	textpipe != invalidpipe &&
	741	(transformState > TRANSFORM_ANY_TRANSLATE \|\|
	742	font.isTransformed() \|\|
	743	fontInfo == null \|\| // Precaution, if true shouldn't get here
	744	(fontInfo.aaHint == SunHints.INTVAL_TEXT_ANTIALIAS_ON) !=
	745	FontUtilities.getFont2D(font).
	746	useAAForPtSize(font.getSize()))) {
	747	textpipe = invalidpipe;
	748	}
	749	this.font = font;
	750	this.fontMetrics = null;
	751	this.validFontInfo = false;
	752	}
	753	}
	754
	755	public FontInfo getFontInfo() {
	756	if (!validFontInfo) {
	757	this.fontInfo = checkFontInfo(this.fontInfo, font, null);
	758	validFontInfo = true;
	759	}
	760	return this.fontInfo;
	761	}
	762
	763	/* Used by drawGlyphVector which specifies its own font. */
	764	public FontInfo getGVFontInfo(Font font, FontRenderContext frc) {
	765	if (glyphVectorFontInfo != null &&
	766	glyphVectorFontInfo.font == font &&
	767	glyphVectorFRC == frc) {
	768	return glyphVectorFontInfo;
	769	} else {
	770	glyphVectorFRC = frc;
	771	return glyphVectorFontInfo =
	772	checkFontInfo(glyphVectorFontInfo, font, frc);
	773	}
	774	}
	775
	776	public FontMetrics getFontMetrics() {
	777	if (this.fontMetrics != null) {
	778	return this.fontMetrics;
	779	}
	780	/* NB the constructor and the setter disallow "font" being null */
	781	return this.fontMetrics =
	782	FontDesignMetrics.getMetrics(font, getFontRenderContext());
	783	}
	784
	785	public FontMetrics getFontMetrics(Font font) {
	786	if ((this.fontMetrics != null) && (font == this.font)) {
	787	return this.fontMetrics;
	788	}
	789	FontMetrics fm =
	790	FontDesignMetrics.getMetrics(font, getFontRenderContext());
	791
	792	if (this.font == font) {
	793	this.fontMetrics = fm;
	794	}
	795	return fm;
	796	}
	797
	798	/**
	799	* Checks to see if a Path intersects the specified Rectangle in device
	800	* space. The rendering attributes taken into account include the
	801	* clip, transform, and stroke attributes.
	802	* @param rect The area in device space to check for a hit.
	803	* @param p The path to check for a hit.
	804	* @param onStroke Flag to choose between testing the stroked or
	805	* the filled path.
	806	* @return True if there is a hit, false otherwise.
	807	* @see #setStroke
	808	* @see #fillPath
	809	* @see #drawPath
	810	* @see #transform
	811	* @see #setTransform
	812	* @see #clip
	813	* @see #setClip
	814	*/
	815	public boolean hit(Rectangle rect, Shape s, boolean onStroke) {
	816	if (onStroke) {
	817	s = stroke.createStrokedShape(s);
	818	}
	819
	820	s = transformShape(s);
	821	if ((constrainX\|constrainY) != 0) {
	822	rect = new Rectangle(rect);
	823	rect.translate(constrainX, constrainY);
	824	}
	825
	826	return s.intersects(rect);
	827	}
	828
	829	/**
	830	* Return the ColorModel associated with this Graphics2D.
	831	*/
	832	public ColorModel getDeviceColorModel() {
	833	return surfaceData.getColorModel();
	834	}
	835
	836	/**
	837	* Return the device configuration associated with this Graphics2D.
	838	*/
	839	public GraphicsConfiguration getDeviceConfiguration() {
	840	return surfaceData.getDeviceConfiguration();
	841	}
	842
	843	/**
	844	* Return the SurfaceData object assigned to manage the destination
	845	* drawable surface of this Graphics2D.
	846	*/
	847	public final SurfaceData getSurfaceData() {
	848	return surfaceData;
	849	}
	850
	851	/**
	852	* Sets the Composite in the current graphics state. Composite is used
	853	* in all drawing methods such as drawImage, drawString, drawPath,
	854	* and fillPath. It specifies how new pixels are to be combined with
	855	* the existing pixels on the graphics device in the rendering process.
	856	* @param comp The Composite object to be used for drawing.
	857	* @see java.awt.Graphics#setXORMode
	858	* @see java.awt.Graphics#setPaintMode
	859	* @see AlphaComposite
	860	*/
	861	public void setComposite(Composite comp) {
	862	if (composite == comp) {
	863	return;
	864	}
	865	int newCompState;
	866	CompositeType newCompType;
	867	if (comp instanceof AlphaComposite) {
	868	AlphaComposite alphacomp = (AlphaComposite) comp;
	869	newCompType = CompositeType.forAlphaComposite(alphacomp);
	870	if (newCompType == CompositeType.SrcOverNoEa) {
	871	if (paintState == PAINT_OPAQUECOLOR \|\|
	872	(paintState > PAINT_ALPHACOLOR &&
	873	paint.getTransparency() == Transparency.OPAQUE))
	874	{
	875	newCompState = COMP_ISCOPY;
	876	} else {
	877	newCompState = COMP_ALPHA;
	878	}
	879	} else if (newCompType == CompositeType.SrcNoEa \|\|
	880	newCompType == CompositeType.Src \|\|
	881	newCompType == CompositeType.Clear)
	882	{
	883	newCompState = COMP_ISCOPY;
	884	} else if (surfaceData.getTransparency() == Transparency.OPAQUE &&
	885	newCompType == CompositeType.SrcIn)
	886	{
	887	newCompState = COMP_ISCOPY;
	888	} else {
	889	newCompState = COMP_ALPHA;
	890	}
	891	} else if (comp instanceof XORComposite) {
	892	newCompState = COMP_XOR;
	893	newCompType = CompositeType.Xor;
	894	} else if (comp == null) {
	895	throw new IllegalArgumentException("null Composite");
	896	} else {
	897	surfaceData.checkCustomComposite();
	898	newCompState = COMP_CUSTOM;
	899	newCompType = CompositeType.General;
	900	}
	901	if (compositeState != newCompState \|\|
	902	imageComp != newCompType)
	903	{
	904	compositeState = newCompState;
	905	imageComp = newCompType;
	906	invalidatePipe();
	907	validFontInfo = false;
	908	}
	909	composite = comp;
	910	if (paintState <= PAINT_ALPHACOLOR) {
	911	validateColor();
	912	}
	913	}
	914
	915	/**
	916	* Sets the Paint in the current graphics state.
	917	* @param paint The Paint object to be used to generate color in
	918	* the rendering process.
	919	* @see java.awt.Graphics#setColor
	920	* @see GradientPaint
	921	* @see TexturePaint
	922	*/
	923	public void setPaint(Paint paint) {
	924	if (paint instanceof Color) {
	925	setColor((Color) paint);
	926	return;
	927	}
	928	if (paint == null \|\| this.paint == paint) {
	929	return;
	930	}
	931	this.paint = paint;
	932	if (imageComp == CompositeType.SrcOverNoEa) {
	933	// special case where compState depends on opacity of paint
	934	if (paint.getTransparency() == Transparency.OPAQUE) {
	935	if (compositeState != COMP_ISCOPY) {
	936	compositeState = COMP_ISCOPY;
	937	}
	938	} else {
	939	if (compositeState == COMP_ISCOPY) {
	940	compositeState = COMP_ALPHA;
	941	}
	942	}
	943	}
	944	Class paintClass = paint.getClass();
	945	if (paintClass == GradientPaint.class) {
	946	paintState = PAINT_GRADIENT;
	947	} else if (paintClass == LinearGradientPaint.class) {
	948	paintState = PAINT_LIN_GRADIENT;
	949	} else if (paintClass == RadialGradientPaint.class) {
	950	paintState = PAINT_RAD_GRADIENT;
	951	} else if (paintClass == TexturePaint.class) {
	952	paintState = PAINT_TEXTURE;
	953	} else {
	954	paintState = PAINT_CUSTOM;
	955	}
	956	validFontInfo = false;
	957	invalidatePipe();
	958	}
	959
	960	static final int NON_UNIFORM_SCALE_MASK =
	961	(AffineTransform.TYPE_GENERAL_TRANSFORM \|
	962	AffineTransform.TYPE_GENERAL_SCALE);
	963	public static final double MinPenSizeAA =
	964	sun.java2d.pipe.RenderingEngine.getInstance().getMinimumAAPenSize();
	965	public static final double MinPenSizeAASquared =
	966	(MinPenSizeAA * MinPenSizeAA);
	967	// Since inaccuracies in the trig package can cause us to
	968	// calculated a rotated pen width of just slightly greater
	969	// than 1.0, we add a fudge factor to our comparison value
	970	// here so that we do not misclassify single width lines as
	971	// wide lines under certain rotations.
	972	public static final double MinPenSizeSquared = 1.000000001;
	973
	974	private void validateBasicStroke(BasicStroke bs) {
	975	boolean aa = (antialiasHint == SunHints.INTVAL_ANTIALIAS_ON);
	976	if (transformState < TRANSFORM_TRANSLATESCALE) {
	977	if (aa) {
	978	if (bs.getLineWidth() <= MinPenSizeAA) {
	979	if (bs.getDashArray() == null) {
	980	strokeState = STROKE_THIN;
	981	} else {
	982	strokeState = STROKE_THINDASHED;
	983	}
	984	} else {
	985	strokeState = STROKE_WIDE;
	986	}
	987	} else {
	988	if (bs == defaultStroke) {
	989	strokeState = STROKE_THIN;
	990	} else if (bs.getLineWidth() <= 1.0f) {
	991	if (bs.getDashArray() == null) {
	992	strokeState = STROKE_THIN;
	993	} else {
	994	strokeState = STROKE_THINDASHED;
	995	}
	996	} else {
	997	strokeState = STROKE_WIDE;
	998	}
	999	}
	1000	} else {
	1001	double widthsquared;
	1002	if ((transform.getType() & NON_UNIFORM_SCALE_MASK) == 0) {
	1003	/* sqrt omitted, compare to squared limits below. */
	1004	widthsquared = Math.abs(transform.getDeterminant());
	1005	} else {
	1006	/* First calculate the "maximum scale" of this transform. */
	1007	double A = transform.getScaleX(); // m00
	1008	double C = transform.getShearX(); // m01
	1009	double B = transform.getShearY(); // m10
	1010	double D = transform.getScaleY(); // m11
	1011
	1012	/*
	1013	* Given a 2 x 2 affine matrix [ A B ] such that
	1014	* [ C D ]
	1015	* v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to
	1016	* find the maximum magnitude (norm) of the vector v'
	1017	* with the constraint (x^2 + y^2 = 1).
	1018	* The equation to maximize is
	1019	* \|v'\| = sqrt((Ax+Cy)^2+(Bx+Dy)^2)
	1020	* or \|v'\| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2).
	1021	* Since sqrt is monotonic we can maximize \|v'\|^2
	1022	* instead and plug in the substitution y = sqrt(1 - x^2).
	1023	* Trigonometric equalities can then be used to get
	1024	* rid of most of the sqrt terms.
	1025	*/
	1026	double EA = AA + BB; // x^2 coefficient
	1027	double EB = 2(AC + B*D); // xy coefficient
	1028	double EC = CC + DD; // y^2 coefficient
	1029
	1030	/*
	1031	* There is a lot of calculus omitted here.
	1032	*
	1033	* Conceptually, in the interests of understanding the
	1034	* terms that the calculus produced we can consider
	1035	* that EA and EC end up providing the lengths along
	1036	* the major axes and the hypot term ends up being an
	1037	* adjustment for the additional length along the off-axis
	1038	* angle of rotated or sheared ellipses as well as an
	1039	* adjustment for the fact that the equation below
	1040	* averages the two major axis lengths. (Notice that
	1041	* the hypot term contains a part which resolves to the
	1042	* difference of these two axis lengths in the absence
	1043	* of rotation.)
	1044	*
	1045	* In the calculus, the ratio of the EB and (EA-EC) terms
	1046	* ends up being the tangent of 2*theta where theta is
	1047	* the angle that the long axis of the ellipse makes
	1048	* with the horizontal axis. Thus, this equation is
	1049	* calculating the length of the hypotenuse of a triangle
	1050	* along that axis.
	1051	*/
	1052	double hypot = Math.sqrt(EBEB + (EA-EC)(EA-EC));
	1053
	1054	/* sqrt omitted, compare to squared limits below. */
	1055	widthsquared = ((EA + EC + hypot)/2.0);
	1056	}
	1057	if (bs != defaultStroke) {
	1058	widthsquared = bs.getLineWidth() bs.getLineWidth();
	1059	}
	1060	if (widthsquared <=
	1061	(aa ? MinPenSizeAASquared : MinPenSizeSquared))
	1062	{
	1063	if (bs.getDashArray() == null) {
	1064	strokeState = STROKE_THIN;
	1065	} else {
	1066	strokeState = STROKE_THINDASHED;
	1067	}
	1068	} else {
	1069	strokeState = STROKE_WIDE;
	1070	}
	1071	}
	1072	}
	1073
	1074	/*
	1075	* Sets the Stroke in the current graphics state.
	1076	* @param s The Stroke object to be used to stroke a Path in
	1077	* the rendering process.
	1078	* @see BasicStroke
	1079	*/
	1080	public void setStroke(Stroke s) {
	1081	if (s == null) {
	1082	throw new IllegalArgumentException("null Stroke");
	1083	}
	1084	int saveStrokeState = strokeState;
	1085	stroke = s;
	1086	if (s instanceof BasicStroke) {
	1087	validateBasicStroke((BasicStroke) s);
	1088	} else {
	1089	strokeState = STROKE_CUSTOM;
	1090	}
	1091	if (strokeState != saveStrokeState) {
	1092	invalidatePipe();
	1093	}
	1094	}
	1095
	1096	/**
	1097	* Sets the preferences for the rendering algorithms.
	1098	* Hint categories include controls for rendering quality and
	1099	* overall time/quality trade-off in the rendering process.
	1100	* @param hintKey The key of hint to be set. The strings are
	1101	* defined in the RenderingHints class.
	1102	* @param hintValue The value indicating preferences for the specified
	1103	* hint category. These strings are defined in the RenderingHints
	1104	* class.
	1105	* @see RenderingHints
	1106	*/
	1107	public void setRenderingHint(Key hintKey, Object hintValue) {
	1108	// If we recognize the key, we must recognize the value
	1109	// otherwise throw an IllegalArgumentException
	1110	// and do not change the Hints object
	1111	// If we do not recognize the key, just pass it through
	1112	// to the Hints object untouched
	1113	if (!hintKey.isCompatibleValue(hintValue)) {
	1114	throw new IllegalArgumentException
	1115	(hintValue+" is not compatible with "+hintKey);
	1116	}
	1117	if (hintKey instanceof SunHints.Key) {
	1118	boolean stateChanged;
	1119	boolean textStateChanged = false;
	1120	boolean recognized = true;
	1121	SunHints.Key sunKey = (SunHints.Key) hintKey;
	1122	int newHint;
	1123	if (sunKey == SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST) {
	1124	newHint = ((Integer)hintValue).intValue();
	1125	} else {
	1126	newHint = ((SunHints.Value) hintValue).getIndex();
	1127	}
	1128	switch (sunKey.getIndex()) {
	1129	case SunHints.INTKEY_RENDERING:
	1130	stateChanged = (renderHint != newHint);
	1131	if (stateChanged) {
	1132	renderHint = newHint;
	1133	if (interpolationHint == -1) {
	1134	interpolationType =
	1135	(newHint == SunHints.INTVAL_RENDER_QUALITY
	1136	? AffineTransformOp.TYPE_BILINEAR
	1137	: AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
	1138	}
	1139	}
	1140	break;
	1141	case SunHints.INTKEY_ANTIALIASING:
	1142	stateChanged = (antialiasHint != newHint);
	1143	antialiasHint = newHint;
	1144	if (stateChanged) {
	1145	textStateChanged =
	1146	(textAntialiasHint ==
	1147	SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT);
	1148	if (strokeState != STROKE_CUSTOM) {
	1149	validateBasicStroke((BasicStroke) stroke);
	1150	}
	1151	}
	1152	break;
	1153	case SunHints.INTKEY_TEXT_ANTIALIASING:
	1154	stateChanged = (textAntialiasHint != newHint);
	1155	textStateChanged = stateChanged;
	1156	textAntialiasHint = newHint;
	1157	break;
	1158	case SunHints.INTKEY_FRACTIONALMETRICS:
	1159	stateChanged = (fractionalMetricsHint != newHint);
	1160	textStateChanged = stateChanged;
	1161	fractionalMetricsHint = newHint;
	1162	break;
	1163	case SunHints.INTKEY_AATEXT_LCD_CONTRAST:
	1164	stateChanged = false;
	1165	/* Already have validated it is an int 100 <= newHint <= 250 */
	1166	lcdTextContrast = newHint;
	1167	break;
	1168	case SunHints.INTKEY_INTERPOLATION:
	1169	interpolationHint = newHint;
	1170	switch (newHint) {
	1171	case SunHints.INTVAL_INTERPOLATION_BICUBIC:
	1172	newHint = AffineTransformOp.TYPE_BICUBIC;
	1173	break;
	1174	case SunHints.INTVAL_INTERPOLATION_BILINEAR:
	1175	newHint = AffineTransformOp.TYPE_BILINEAR;
	1176	break;
	1177	default:
	1178	case SunHints.INTVAL_INTERPOLATION_NEAREST_NEIGHBOR:
	1179	newHint = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
	1180	break;
	1181	}
	1182	stateChanged = (interpolationType != newHint);
	1183	interpolationType = newHint;
	1184	break;
	1185	case SunHints.INTKEY_STROKE_CONTROL:
	1186	stateChanged = (strokeHint != newHint);
	1187	strokeHint = newHint;
	1188	break;
	1189	default:
	1190	recognized = false;
	1191	stateChanged = false;
	1192	break;
	1193	}
	1194	if (recognized) {
	1195	if (stateChanged) {
	1196	invalidatePipe();
	1197	if (textStateChanged) {
	1198	fontMetrics = null;
	1199	this.cachedFRC = null;
	1200	validFontInfo = false;
	1201	this.glyphVectorFontInfo = null;
	1202	}
	1203	}
	1204	if (hints != null) {
	1205	hints.put(hintKey, hintValue);
	1206	}
	1207	return;
	1208	}
	1209	}
	1210	// Nothing we recognize so none of "our state" has changed
	1211	if (hints == null) {
	1212	hints = makeHints(null);
	1213	}
	1214	hints.put(hintKey, hintValue);
	1215	}
	1216
	1217
	1218	/**
	1219	* Returns the preferences for the rendering algorithms.
	1220	* @param hintCategory The category of hint to be set. The strings
	1221	* are defined in the RenderingHints class.
	1222	* @return The preferences for rendering algorithms. The strings
	1223	* are defined in the RenderingHints class.
	1224	* @see RenderingHints
	1225	*/
	1226	public Object getRenderingHint(Key hintKey) {
	1227	if (hints != null) {
	1228	return hints.get(hintKey);
	1229	}
	1230	if (!(hintKey instanceof SunHints.Key)) {
	1231	return null;
	1232	}
	1233	int keyindex = ((SunHints.Key)hintKey).getIndex();
	1234	switch (keyindex) {
	1235	case SunHints.INTKEY_RENDERING:
	1236	return SunHints.Value.get(SunHints.INTKEY_RENDERING,
	1237	renderHint);
	1238	case SunHints.INTKEY_ANTIALIASING:
	1239	return SunHints.Value.get(SunHints.INTKEY_ANTIALIASING,
	1240	antialiasHint);
	1241	case SunHints.INTKEY_TEXT_ANTIALIASING:
	1242	return SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING,
	1243	textAntialiasHint);
	1244	case SunHints.INTKEY_FRACTIONALMETRICS:
	1245	return SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
	1246	fractionalMetricsHint);
	1247	case SunHints.INTKEY_AATEXT_LCD_CONTRAST:
	1248	return new Integer(lcdTextContrast);
	1249	case SunHints.INTKEY_INTERPOLATION:
	1250	switch (interpolationHint) {
	1251	case SunHints.INTVAL_INTERPOLATION_NEAREST_NEIGHBOR:
	1252	return SunHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
	1253	case SunHints.INTVAL_INTERPOLATION_BILINEAR:
	1254	return SunHints.VALUE_INTERPOLATION_BILINEAR;
	1255	case SunHints.INTVAL_INTERPOLATION_BICUBIC:
	1256	return SunHints.VALUE_INTERPOLATION_BICUBIC;
	1257	}
	1258	return null;
	1259	case SunHints.INTKEY_STROKE_CONTROL:
	1260	return SunHints.Value.get(SunHints.INTKEY_STROKE_CONTROL,
	1261	strokeHint);
	1262	}
	1263	return null;
	1264	}
	1265
	1266	/**
	1267	* Sets the preferences for the rendering algorithms.
	1268	* Hint categories include controls for rendering quality and
	1269	* overall time/quality trade-off in the rendering process.
	1270	* @param hints The rendering hints to be set
	1271	* @see RenderingHints
	1272	*/
	1273	public void setRenderingHints(Map<?,?> hints) {
	1274	this.hints = null;
	1275	renderHint = SunHints.INTVAL_RENDER_DEFAULT;
	1276	antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
	1277	textAntialiasHint = SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT;
	1278	fractionalMetricsHint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
	1279	lcdTextContrast = lcdTextContrastDefaultValue;
	1280	interpolationHint = -1;
	1281	interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
	1282	boolean customHintPresent = false;
	1283	Iterator iter = hints.keySet().iterator();
	1284	while (iter.hasNext()) {
	1285	Object key = iter.next();
	1286	if (key == SunHints.KEY_RENDERING \|\|
	1287	key == SunHints.KEY_ANTIALIASING \|\|
	1288	key == SunHints.KEY_TEXT_ANTIALIASING \|\|
	1289	key == SunHints.KEY_FRACTIONALMETRICS \|\|
	1290	key == SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST \|\|
	1291	key == SunHints.KEY_STROKE_CONTROL \|\|
	1292	key == SunHints.KEY_INTERPOLATION)
	1293	{
	1294	setRenderingHint((Key) key, hints.get(key));
	1295	} else {
	1296	customHintPresent = true;
	1297	}
	1298	}
	1299	if (customHintPresent) {
	1300	this.hints = makeHints(hints);
	1301	}
	1302	invalidatePipe();
	1303	}
	1304
	1305	/**
	1306	* Adds a number of preferences for the rendering algorithms.
	1307	* Hint categories include controls for rendering quality and
	1308	* overall time/quality trade-off in the rendering process.
	1309	* @param hints The rendering hints to be set
	1310	* @see RenderingHints
	1311	*/
	1312	public void addRenderingHints(Map<?,?> hints) {
	1313	boolean customHintPresent = false;
	1314	Iterator iter = hints.keySet().iterator();
	1315	while (iter.hasNext()) {
	1316	Object key = iter.next();
	1317	if (key == SunHints.KEY_RENDERING \|\|
	1318	key == SunHints.KEY_ANTIALIASING \|\|
	1319	key == SunHints.KEY_TEXT_ANTIALIASING \|\|
	1320	key == SunHints.KEY_FRACTIONALMETRICS \|\|
	1321	key == SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST \|\|
	1322	key == SunHints.KEY_STROKE_CONTROL \|\|
	1323	key == SunHints.KEY_INTERPOLATION)
	1324	{
	1325	setRenderingHint((Key) key, hints.get(key));
	1326	} else {
	1327	customHintPresent = true;
	1328	}
	1329	}
	1330	if (customHintPresent) {
	1331	if (this.hints == null) {
	1332	this.hints = makeHints(hints);
	1333	} else {
	1334	this.hints.putAll(hints);
	1335	}
	1336	}
	1337	}
	1338
	1339	/**
	1340	* Gets the preferences for the rendering algorithms.
	1341	* Hint categories include controls for rendering quality and
	1342	* overall time/quality trade-off in the rendering process.
	1343	* @see RenderingHints
	1344	*/
	1345	public RenderingHints getRenderingHints() {
	1346	if (hints == null) {
	1347	return makeHints(null);
	1348	} else {
	1349	return (RenderingHints) hints.clone();
	1350	}
	1351	}
	1352
	1353	RenderingHints makeHints(Map hints) {
	1354	RenderingHints model = new RenderingHints(hints);
	1355	model.put(SunHints.KEY_RENDERING,
	1356	SunHints.Value.get(SunHints.INTKEY_RENDERING,
	1357	renderHint));
	1358	model.put(SunHints.KEY_ANTIALIASING,
	1359	SunHints.Value.get(SunHints.INTKEY_ANTIALIASING,
	1360	antialiasHint));
	1361	model.put(SunHints.KEY_TEXT_ANTIALIASING,
	1362	SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING,
	1363	textAntialiasHint));
	1364	model.put(SunHints.KEY_FRACTIONALMETRICS,
	1365	SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
	1366	fractionalMetricsHint));
	1367	model.put(SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST,
	1368	Integer.valueOf(lcdTextContrast));
	1369	Object value;
	1370	switch (interpolationHint) {
	1371	case SunHints.INTVAL_INTERPOLATION_NEAREST_NEIGHBOR:
	1372	value = SunHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
	1373	break;
	1374	case SunHints.INTVAL_INTERPOLATION_BILINEAR:
	1375	value = SunHints.VALUE_INTERPOLATION_BILINEAR;
	1376	break;
	1377	case SunHints.INTVAL_INTERPOLATION_BICUBIC:
	1378	value = SunHints.VALUE_INTERPOLATION_BICUBIC;
	1379	break;
	1380	default:
	1381	value = null;
	1382	break;
	1383	}
	1384	if (value != null) {
	1385	model.put(SunHints.KEY_INTERPOLATION, value);
	1386	}
	1387	model.put(SunHints.KEY_STROKE_CONTROL,
	1388	SunHints.Value.get(SunHints.INTKEY_STROKE_CONTROL,
	1389	strokeHint));
	1390	return model;
	1391	}
	1392
	1393	/**
	1394	* Concatenates the current transform of this Graphics2D with a
	1395	* translation transformation.
	1396	* This is equivalent to calling transform(T), where T is an
	1397	* AffineTransform represented by the following matrix:
	1398	* <pre>
	1399	* [ 1 0 tx ]
	1400	* [ 0 1 ty ]
	1401	* [ 0 0 1 ]
	1402	* </pre>
	1403	*/
	1404	public void translate(double tx, double ty) {
	1405	transform.translate(tx, ty);
	1406	invalidateTransform();
	1407	}
	1408
	1409	/**
	1410	* Concatenates the current transform of this Graphics2D with a
	1411	* rotation transformation.
	1412	* This is equivalent to calling transform(R), where R is an
	1413	* AffineTransform represented by the following matrix:
	1414	* <pre>
	1415	* [ cos(theta) -sin(theta) 0 ]
	1416	* [ sin(theta) cos(theta) 0 ]
	1417	* [ 0 0 1 ]
	1418	* </pre>
	1419	* Rotating with a positive angle theta rotates points on the positive
	1420	* x axis toward the positive y axis.
	1421	* @param theta The angle of rotation in radians.
	1422	*/
	1423	public void rotate(double theta) {
	1424	transform.rotate(theta);
	1425	invalidateTransform();
	1426	}
	1427
	1428	/**
	1429	* Concatenates the current transform of this Graphics2D with a
	1430	* translated rotation transformation.
	1431	* This is equivalent to the following sequence of calls:
	1432	* <pre>
	1433	* translate(x, y);
	1434	* rotate(theta);
	1435	* translate(-x, -y);
	1436	* </pre>
	1437	* Rotating with a positive angle theta rotates points on the positive
	1438	* x axis toward the positive y axis.
	1439	* @param theta The angle of rotation in radians.
	1440	* @param x The x coordinate of the origin of the rotation
	1441	* @param y The x coordinate of the origin of the rotation
	1442	*/
	1443	public void rotate(double theta, double x, double y) {
	1444	transform.rotate(theta, x, y);
	1445	invalidateTransform();
	1446	}
	1447
	1448	/**
	1449	* Concatenates the current transform of this Graphics2D with a
	1450	* scaling transformation.
	1451	* This is equivalent to calling transform(S), where S is an
	1452	* AffineTransform represented by the following matrix:
	1453	* <pre>
	1454	* [ sx 0 0 ]
	1455	* [ 0 sy 0 ]
	1456	* [ 0 0 1 ]
	1457	* </pre>
	1458	*/
	1459	public void scale(double sx, double sy) {
	1460	transform.scale(sx, sy);
	1461	invalidateTransform();
	1462	}
	1463
	1464	/**
	1465	* Concatenates the current transform of this Graphics2D with a
	1466	* shearing transformation.
	1467	* This is equivalent to calling transform(SH), where SH is an
	1468	* AffineTransform represented by the following matrix:
	1469	* <pre>
	1470	* [ 1 shx 0 ]
	1471	* [ shy 1 0 ]
	1472	* [ 0 0 1 ]
	1473	* </pre>
	1474	* @param shx The factor by which coordinates are shifted towards the
	1475	* positive X axis direction according to their Y coordinate
	1476	* @param shy The factor by which coordinates are shifted towards the
	1477	* positive Y axis direction according to their X coordinate
	1478	*/
	1479	public void shear(double shx, double shy) {
	1480	transform.shear(shx, shy);
	1481	invalidateTransform();
	1482	}
	1483
	1484	/**
	1485	* Composes a Transform object with the transform in this
	1486	* Graphics2D according to the rule last-specified-first-applied.
	1487	* If the currrent transform is Cx, the result of composition
	1488	* with Tx is a new transform Cx'. Cx' becomes the current
	1489	* transform for this Graphics2D.
	1490	* Transforming a point p by the updated transform Cx' is
	1491	* equivalent to first transforming p by Tx and then transforming
	1492	* the result by the original transform Cx. In other words,
	1493	* Cx'(p) = Cx(Tx(p)).
	1494	* A copy of the Tx is made, if necessary, so further
	1495	* modifications to Tx do not affect rendering.
	1496	* @param Tx The Transform object to be composed with the current
	1497	* transform.
	1498	* @see #setTransform
	1499	* @see AffineTransform
	1500	*/
	1501	public void transform(AffineTransform xform) {
	1502	this.transform.concatenate(xform);
	1503	invalidateTransform();
	1504	}
	1505
	1506	/**
	1507	* Translate
	1508	*/
	1509	public void translate(int x, int y) {
	1510	transform.translate(x, y);
	1511	if (transformState <= TRANSFORM_INT_TRANSLATE) {
	1512	transX += x;
	1513	transY += y;
	1514	transformState = (((transX \| transY) == 0) ?
	1515	TRANSFORM_ISIDENT : TRANSFORM_INT_TRANSLATE);
	1516	} else {
	1517	invalidateTransform();
	1518	}
	1519	}
	1520
	1521	/**
	1522	* Sets the Transform in the current graphics state.
	1523	* @param Tx The Transform object to be used in the rendering process.
	1524	* @see #transform
	1525	* @see TransformChain
	1526	* @see AffineTransform
	1527	*/
	1528	public void setTransform(AffineTransform Tx) {
	1529	if ((constrainX\|constrainY) == 0) {
	1530	transform.setTransform(Tx);
	1531	} else {
	1532	transform.setToTranslation(constrainX, constrainY);
	1533	transform.concatenate(Tx);
	1534	}
	1535	invalidateTransform();
	1536	}
	1537
	1538	protected void invalidateTransform() {
	1539	int type = transform.getType();
	1540	int origTransformState = transformState;
	1541	if (type == AffineTransform.TYPE_IDENTITY) {
	1542	transformState = TRANSFORM_ISIDENT;
	1543	transX = transY = 0;
	1544	} else if (type == AffineTransform.TYPE_TRANSLATION) {
	1545	double dtx = transform.getTranslateX();
	1546	double dty = transform.getTranslateY();
	1547	transX = (int) Math.floor(dtx + 0.5);
	1548	transY = (int) Math.floor(dty + 0.5);
	1549	if (dtx == transX && dty == transY) {
	1550	transformState = TRANSFORM_INT_TRANSLATE;
	1551	} else {
	1552	transformState = TRANSFORM_ANY_TRANSLATE;
	1553	}
	1554	} else if ((type & (AffineTransform.TYPE_FLIP \|
	1555	AffineTransform.TYPE_MASK_ROTATION \|
	1556	AffineTransform.TYPE_GENERAL_TRANSFORM)) == 0)
	1557	{
	1558	transformState = TRANSFORM_TRANSLATESCALE;
	1559	transX = transY = 0;
	1560	} else {
	1561	transformState = TRANSFORM_GENERIC;
	1562	transX = transY = 0;
	1563	}
	1564
	1565	if (transformState >= TRANSFORM_TRANSLATESCALE \|\|
	1566	origTransformState >= TRANSFORM_TRANSLATESCALE)
	1567	{
	1568	/* Its only in this case that the previous or current transform
	1569	* was more than a translate that font info is invalidated
	1570	*/
	1571	cachedFRC = null;
	1572	this.validFontInfo = false;
	1573	this.fontMetrics = null;
	1574	this.glyphVectorFontInfo = null;
	1575
	1576	if (transformState != origTransformState) {
	1577	invalidatePipe();
	1578	}
	1579	}
	1580	if (strokeState != STROKE_CUSTOM) {
	1581	validateBasicStroke((BasicStroke) stroke);
	1582	}
	1583	}
	1584
	1585	/**
	1586	* Returns the current Transform in the Graphics2D state.
	1587	* @see #transform
	1588	* @see #setTransform
	1589	*/
	1590	public AffineTransform getTransform() {
	1591	if ((constrainX\|constrainY) == 0) {
	1592	return new AffineTransform(transform);
	1593	}
	1594	AffineTransform tx =
	1595	AffineTransform.getTranslateInstance(-constrainX, -constrainY);
	1596	tx.concatenate(transform);
	1597	return tx;
	1598	}
	1599
	1600	/**
	1601	* Returns the current Transform ignoring the "constrain"
	1602	* rectangle.
	1603	*/
	1604	public AffineTransform cloneTransform() {
	1605	return new AffineTransform(transform);
	1606	}
	1607
	1608	/**
	1609	* Returns the current Paint in the Graphics2D state.
	1610	* @see #setPaint
	1611	* @see java.awt.Graphics#setColor
	1612	*/
	1613	public Paint getPaint() {
	1614	return paint;
	1615	}
	1616
	1617	/**
	1618	* Returns the current Composite in the Graphics2D state.
	1619	* @see #setComposite
	1620	*/
	1621	public Composite getComposite() {
	1622	return composite;
	1623	}
	1624
	1625	public Color getColor() {
	1626	return foregroundColor;
	1627	}
	1628
	1629	/*
	1630	* Validate the eargb and pixel fields against the current color.
	1631	*
	1632	* The eargb field must take into account the extraAlpha
	1633	* value of an AlphaComposite. It may also take into account
	1634	* the Fsrc Porter-Duff blending function if such a function is
	1635	* a constant (see handling of Clear mode below). For instance,
	1636	* by factoring in the (Fsrc == 0) state of the Clear mode we can
	1637	* use a SrcNoEa loop just as easily as a general Alpha loop
	1638	* since the math will be the same in both cases.
	1639	*
	1640	* The pixel field will always be the best pixel data choice for
	1641	* the final result of all calculations applied to the eargb field.
	1642	*
	1643	* Note that this method is only necessary under the following
	1644	* conditions:
	1645	* (paintState <= PAINT_ALPHA_COLOR &&
	1646	* compositeState <= COMP_CUSTOM)
	1647	* though nothing bad will happen if it is run in other states.
	1648	*/
	1649	final void validateColor() {
	1650	int eargb;
	1651	if (imageComp == CompositeType.Clear) {
	1652	eargb = 0;
	1653	} else {
	1654	eargb = foregroundColor.getRGB();
	1655	if (compositeState <= COMP_ALPHA &&
	1656	imageComp != CompositeType.SrcNoEa &&
	1657	imageComp != CompositeType.SrcOverNoEa)
	1658	{
	1659	AlphaComposite alphacomp = (AlphaComposite) composite;
	1660	int a = Math.round(alphacomp.getAlpha() * (eargb >>> 24));
	1661	eargb = (eargb & 0x00ffffff) \| (a << 24);
	1662	}
	1663	}
	1664	this.eargb = eargb;
	1665	this.pixel = surfaceData.pixelFor(eargb);
	1666	}
	1667
	1668	public void setColor(Color color) {
	1669	if (color == null \|\| color == paint) {
	1670	return;
	1671	}
	1672	this.paint = foregroundColor = color;
	1673	validateColor();
	1674	if ((eargb >> 24) == -1) {
	1675	if (paintState == PAINT_OPAQUECOLOR) {
	1676	return;
	1677	}
	1678	paintState = PAINT_OPAQUECOLOR;
	1679	if (imageComp == CompositeType.SrcOverNoEa) {
	1680	// special case where compState depends on opacity of paint
	1681	compositeState = COMP_ISCOPY;
	1682	}
	1683	} else {
	1684	if (paintState == PAINT_ALPHACOLOR) {
	1685	return;
	1686	}
	1687	paintState = PAINT_ALPHACOLOR;
	1688	if (imageComp == CompositeType.SrcOverNoEa) {
	1689	// special case where compState depends on opacity of paint
	1690	compositeState = COMP_ALPHA;
	1691	}
	1692	}
	1693	validFontInfo = false;
	1694	invalidatePipe();
	1695	}
	1696
	1697	/**
	1698	* Sets the background color in this context used for clearing a region.
	1699	* When Graphics2D is constructed for a component, the backgroung color is
	1700	* inherited from the component. Setting the background color in the
	1701	* Graphics2D context only affects the subsequent clearRect() calls and
	1702	* not the background color of the component. To change the background
	1703	* of the component, use appropriate methods of the component.
	1704	* @param color The background color that should be used in
	1705	* subsequent calls to clearRect().
	1706	* @see getBackground
	1707	* @see Graphics.clearRect()
	1708	*/
	1709	public void setBackground(Color color) {
	1710	backgroundColor = color;
	1711	}
	1712
	1713	/**
	1714	* Returns the background color used for clearing a region.
	1715	* @see setBackground
	1716	*/
	1717	public Color getBackground() {
	1718	return backgroundColor;
	1719	}
	1720
	1721	/**
	1722	* Returns the current Stroke in the Graphics2D state.
	1723	* @see setStroke
	1724	*/
	1725	public Stroke getStroke() {
	1726	return stroke;
	1727	}
	1728
	1729	public Rectangle getClipBounds() {
	1730	Rectangle r;
	1731	if (clipState == CLIP_DEVICE) {
	1732	r = null;
	1733	} else if (transformState <= TRANSFORM_INT_TRANSLATE) {
	1734	if (usrClip instanceof Rectangle) {
	1735	r = new Rectangle((Rectangle) usrClip);
	1736	} else {
	1737	r = usrClip.getBounds();
	1738	}
	1739	r.translate(-transX, -transY);
	1740	} else {
	1741	r = getClip().getBounds();
	1742	}
	1743	return r;
	1744	}
	1745
	1746	public Rectangle getClipBounds(Rectangle r) {
	1747	if (clipState != CLIP_DEVICE) {
	1748	if (transformState <= TRANSFORM_INT_TRANSLATE) {
	1749	if (usrClip instanceof Rectangle) {
	1750	r.setBounds((Rectangle) usrClip);
	1751	} else {
	1752	r.setBounds(usrClip.getBounds());
	1753	}
	1754	r.translate(-transX, -transY);
	1755	} else {
	1756	r.setBounds(getClip().getBounds());
	1757	}
	1758	} else if (r == null) {
	1759	throw new NullPointerException("null rectangle parameter");
	1760	}
	1761	return r;
	1762	}
	1763
	1764	public boolean hitClip(int x, int y, int width, int height) {
	1765	if (width <= 0 \|\| height <= 0) {
	1766	return false;
	1767	}
	1768	if (transformState > TRANSFORM_INT_TRANSLATE) {
	1769	// Note: Technically the most accurate test would be to
	1770	// raster scan the parallelogram of the transformed rectangle
	1771	// and do a span for span hit test against the clip, but for
	1772	// speed we approximate the test with a bounding box of the
	1773	// transformed rectangle. The cost of rasterizing the
	1774	// transformed rectangle is probably high enough that it is
	1775	// not worth doing so to save the caller from having to call
	1776	// a rendering method where we will end up discovering the
	1777	// same answer in about the same amount of time anyway.
	1778	// This logic breaks down if this hit test is being performed
	1779	// on the bounds of a group of shapes in which case it might
	1780	// be beneficial to be a little more accurate to avoid lots
	1781	// of subsequent rendering calls. In either case, this relaxed
	1782	// test should not be significantly less accurate than the
	1783	// optimal test for most transforms and so the conservative
	1784	// answer should not cause too much extra work.
	1785
	1786	double d[] = {
	1787	x, y,
	1788	x+width, y,
	1789	x, y+height,
	1790	x+width, y+height
	1791	};
	1792	transform.transform(d, 0, d, 0, 4);
	1793	x = (int) Math.floor(Math.min(Math.min(d[0], d[2]),
	1794	Math.min(d[4], d[6])));
	1795	y = (int) Math.floor(Math.min(Math.min(d[1], d[3]),
	1796	Math.min(d[5], d[7])));
	1797	width = (int) Math.ceil(Math.max(Math.max(d[0], d[2]),
	1798	Math.max(d[4], d[6])));
	1799	height = (int) Math.ceil(Math.max(Math.max(d[1], d[3]),
	1800	Math.max(d[5], d[7])));
	1801	} else {
	1802	x += transX;
	1803	y += transY;
	1804	width += x;
	1805	height += y;
	1806	}
	1807	if (!getCompClip().intersectsQuickCheckXYXY(x, y, width, height)) {
	1808	return false;
	1809	}
	1810	// REMIND: We could go one step further here and examine the
	1811	// non-rectangular clip shape more closely if there is one.
	1812	// Since the clip has already been rasterized, the performance
	1813	// penalty of doing the scan is probably still within the bounds
	1814	// of a good tradeoff between speed and quality of the answer.
	1815	return true;
	1816	}
	1817
	1818	protected void validateCompClip() {
	1819	int origClipState = clipState;
	1820	if (usrClip == null) {
	1821	clipState = CLIP_DEVICE;
	1822	clipRegion = devClip;
	1823	} else if (usrClip instanceof Rectangle2D) {
	1824	clipState = CLIP_RECTANGULAR;
	1825	if (usrClip instanceof Rectangle) {
	1826	clipRegion = devClip.getIntersection((Rectangle)usrClip);
	1827	} else {
	1828	clipRegion = devClip.getIntersection(usrClip.getBounds());
	1829	}
	1830	} else {
	1831	PathIterator cpi = usrClip.getPathIterator(null);
	1832	int box[] = new int[4];
	1833	ShapeSpanIterator sr = LoopPipe.getFillSSI(this);
	1834	try {
	1835	sr.setOutputArea(devClip);
	1836	sr.appendPath(cpi);
	1837	sr.getPathBox(box);
	1838	Region r = Region.getInstance(box);
	1839	r.appendSpans(sr);
	1840	clipRegion = r;
	1841	clipState =
	1842	r.isRectangular() ? CLIP_RECTANGULAR : CLIP_SHAPE;
	1843	} finally {
	1844	sr.dispose();
	1845	}
	1846	}
	1847	if (origClipState != clipState &&
	1848	(clipState == CLIP_SHAPE \|\| origClipState == CLIP_SHAPE))
	1849	{
	1850	validFontInfo = false;
	1851	invalidatePipe();
	1852	}
	1853	}
	1854
	1855	static final int NON_RECTILINEAR_TRANSFORM_MASK =
	1856	(AffineTransform.TYPE_GENERAL_TRANSFORM \|
	1857	AffineTransform.TYPE_GENERAL_ROTATION);
	1858
	1859	protected Shape transformShape(Shape s) {
	1860	if (s == null) {
	1861	return null;
	1862	}
	1863	if (transformState > TRANSFORM_INT_TRANSLATE) {
	1864	return transformShape(transform, s);
	1865	} else {
	1866	return transformShape(transX, transY, s);
	1867	}
	1868	}
	1869
	1870	public Shape untransformShape(Shape s) {
	1871	if (s == null) {
	1872	return null;
	1873	}
	1874	if (transformState > TRANSFORM_INT_TRANSLATE) {
	1875	try {
	1876	return transformShape(transform.createInverse(), s);
	1877	} catch (NoninvertibleTransformException e) {
	1878	return null;
	1879	}
	1880	} else {
	1881	return transformShape(-transX, -transY, s);
	1882	}
	1883	}
	1884
	1885	protected static Shape transformShape(int tx, int ty, Shape s) {
	1886	if (s == null) {
	1887	return null;
	1888	}
	1889
	1890	if (s instanceof Rectangle) {
	1891	Rectangle r = s.getBounds();
	1892	r.translate(tx, ty);
	1893	return r;
	1894	}
	1895	if (s instanceof Rectangle2D) {
	1896	Rectangle2D rect = (Rectangle2D) s;
	1897	return new Rectangle2D.Double(rect.getX() + tx,
	1898	rect.getY() + ty,
	1899	rect.getWidth(),
	1900	rect.getHeight());
	1901	}
	1902
	1903	if (tx == 0 && ty == 0) {
	1904	return cloneShape(s);
	1905	}
	1906
	1907	AffineTransform mat = AffineTransform.getTranslateInstance(tx, ty);
	1908	return mat.createTransformedShape(s);
	1909	}
	1910
	1911	protected static Shape transformShape(AffineTransform tx, Shape clip) {
	1912	if (clip == null) {
	1913	return null;
	1914	}
	1915
	1916	if (clip instanceof Rectangle2D &&
	1917	(tx.getType() & NON_RECTILINEAR_TRANSFORM_MASK) == 0)
	1918	{
	1919	Rectangle2D rect = (Rectangle2D) clip;
	1920	double matrix[] = new double[4];
	1921	matrix[0] = rect.getX();
	1922	matrix[1] = rect.getY();
	1923	matrix[2] = matrix[0] + rect.getWidth();
	1924	matrix[3] = matrix[1] + rect.getHeight();
	1925	tx.transform(matrix, 0, matrix, 0, 2);
	1926	rect = new Rectangle2D.Float();
	1927	rect.setFrameFromDiagonal(matrix[0], matrix[1],
	1928	matrix[2], matrix[3]);
	1929	return rect;
	1930	}
	1931
	1932	if (tx.isIdentity()) {
	1933	return cloneShape(clip);
	1934	}
	1935
	1936	return tx.createTransformedShape(clip);
	1937	}
	1938
	1939	public void clipRect(int x, int y, int w, int h) {
	1940	clip(new Rectangle(x, y, w, h));
	1941	}
	1942
	1943	public void setClip(int x, int y, int w, int h) {
	1944	setClip(new Rectangle(x, y, w, h));
	1945	}
	1946
	1947	public Shape getClip() {
	1948	return untransformShape(usrClip);
	1949	}
	1950
	1951	public void setClip(Shape sh) {
	1952	usrClip = transformShape(sh);
	1953	validateCompClip();
	1954	}
	1955
	1956	/**
	1957	* Intersects the current clip with the specified Path and sets the
	1958	* current clip to the resulting intersection. The clip is transformed
	1959	* with the current transform in the Graphics2D state before being
	1960	* intersected with the current clip. This method is used to make the
	1961	* current clip smaller. To make the clip larger, use any setClip method.
	1962	* @param p The Path to be intersected with the current clip.
	1963	*/
	1964	public void clip(Shape s) {
	1965	s = transformShape(s);
	1966	if (usrClip != null) {
	1967	s = intersectShapes(usrClip, s, true, true);
	1968	}
	1969	usrClip = s;
	1970	validateCompClip();
	1971	}
	1972
	1973	public void setPaintMode() {
	1974	setComposite(AlphaComposite.SrcOver);
	1975	}
	1976
	1977	public void setXORMode(Color c) {
	1978	if (c == null) {
	1979	throw new IllegalArgumentException("null XORColor");
	1980	}
	1981	setComposite(new XORComposite(c, surfaceData));
	1982	}
	1983
	1984	Blit lastCAblit;
	1985	Composite lastCAcomp;
	1986
	1987	public void copyArea(int x, int y, int w, int h, int dx, int dy) {
	1988	try {
	1989	doCopyArea(x, y, w, h, dx, dy);
	1990	} catch (InvalidPipeException e) {
	1991	revalidateAll();
	1992	try {
	1993	doCopyArea(x, y, w, h, dx, dy);
	1994	} catch (InvalidPipeException e2) {
	1995	// Still catching the exception; we are not yet ready to
	1996	// validate the surfaceData correctly. Fail for now and
	1997	// try again next time around.
	1998	}
	1999	} finally {
	2000	surfaceData.markDirty();
	2001	}
	2002	}
	2003
	2004	private void doCopyArea(int x, int y, int w, int h, int dx, int dy) {
	2005	if (w <= 0 \|\| h <= 0) {
	2006	return;
	2007	}
	2008	SurfaceData theData = surfaceData;
	2009	if (theData.copyArea(this, x, y, w, h, dx, dy)) {
	2010	return;
	2011	}
	2012	if (transformState >= TRANSFORM_TRANSLATESCALE) {
	2013	throw new InternalError("transformed copyArea not implemented yet");
	2014	}
	2015	// REMIND: This method does not deal with missing data from the
	2016	// source object (i.e. it does not send exposure events...)
	2017
	2018	Region clip = getCompClip();
	2019
	2020	Composite comp = composite;
	2021	if (lastCAcomp != comp) {
	2022	SurfaceType dsttype = theData.getSurfaceType();
	2023	CompositeType comptype = imageComp;
	2024	if (CompositeType.SrcOverNoEa.equals(comptype) &&
	2025	theData.getTransparency() == Transparency.OPAQUE)
	2026	{
	2027	comptype = CompositeType.SrcNoEa;
	2028	}
	2029	lastCAblit = Blit.locate(dsttype, comptype, dsttype);
	2030	lastCAcomp = comp;
	2031	}
	2032
	2033	x += transX;
	2034	y += transY;
	2035
	2036	Blit ob = lastCAblit;
	2037	if (dy == 0 && dx > 0 && dx < w) {
	2038	while (w > 0) {
	2039	int partW = Math.min(w, dx);
	2040	w -= partW;
	2041	int sx = x + w;
	2042	ob.Blit(theData, theData, comp, clip,
	2043	sx, y, sx+dx, y+dy, partW, h);
	2044	}
	2045	return;
	2046	}
	2047	if (dy > 0 && dy < h && dx > -w && dx < w) {
	2048	while (h > 0) {
	2049	int partH = Math.min(h, dy);
	2050	h -= partH;
	2051	int sy = y + h;
	2052	ob.Blit(theData, theData, comp, clip,
	2053	x, sy, x+dx, sy+dy, w, partH);
	2054	}
	2055	return;
	2056	}
	2057	ob.Blit(theData, theData, comp, clip, x, y, x+dx, y+dy, w, h);
	2058	}
	2059
	2060	/*
	2061	public void XcopyArea(int x, int y, int w, int h, int dx, int dy) {
	2062	Rectangle rect = new Rectangle(x, y, w, h);
	2063	rect = transformBounds(rect, transform);
	2064	Point2D point = new Point2D.Float(dx, dy);
	2065	Point2D root = new Point2D.Float(0, 0);
	2066	point = transform.transform(point, point);
	2067	root = transform.transform(root, root);
	2068	int fdx = (int)(point.getX()-root.getX());
	2069	int fdy = (int)(point.getY()-root.getY());
	2070
	2071	Rectangle r = getCompBounds().intersection(rect.getBounds());
	2072
	2073	if (r.isEmpty()) {
	2074	return;
	2075	}
	2076
	2077	// Begin Rasterizer for Clip Shape
	2078	boolean skipClip = true;
	2079	byte[] clipAlpha = null;
	2080
	2081	if (clipState == CLIP_SHAPE) {
	2082
	2083	int box[] = new int[4];
	2084
	2085	clipRegion.getBounds(box);
	2086	Rectangle devR = new Rectangle(box[0], box[1],
	2087	box[2] - box[0],
	2088	box[3] - box[1]);
	2089	if (!devR.isEmpty()) {
	2090	OutputManager mgr = getOutputManager();
	2091	RegionIterator ri = clipRegion.getIterator();
	2092	while (ri.nextYRange(box)) {
	2093	int spany = box[1];
	2094	int spanh = box[3] - spany;
	2095	while (ri.nextXBand(box)) {
	2096	int spanx = box[0];
	2097	int spanw = box[2] - spanx;
	2098	mgr.copyArea(this, null,
	2099	spanw, 0,
	2100	spanx, spany,
	2101	spanw, spanh,
	2102	fdx, fdy,
	2103	null);
	2104	}
	2105	}
	2106	}
	2107	return;
	2108	}
	2109	// End Rasterizer for Clip Shape
	2110
	2111	getOutputManager().copyArea(this, null,
	2112	r.width, 0,
	2113	r.x, r.y, r.width,
	2114	r.height, fdx, fdy,
	2115	null);
	2116	}
	2117	*/
	2118
	2119	public void drawLine(int x1, int y1, int x2, int y2) {
	2120	try {
	2121	drawpipe.drawLine(this, x1, y1, x2, y2);
	2122	} catch (InvalidPipeException e) {
	2123	revalidateAll();
	2124	try {
	2125	drawpipe.drawLine(this, x1, y1, x2, y2);
	2126	} catch (InvalidPipeException e2) {
	2127	// Still catching the exception; we are not yet ready to
	2128	// validate the surfaceData correctly. Fail for now and
	2129	// try again next time around.
	2130	}
	2131	} finally {
	2132	surfaceData.markDirty();
	2133	}
	2134	}
	2135
	2136	public void drawRoundRect(int x, int y, int w, int h, int arcW, int arcH) {
	2137	try {
	2138	drawpipe.drawRoundRect(this, x, y, w, h, arcW, arcH);
	2139	} catch (InvalidPipeException e) {
	2140	revalidateAll();
	2141	try {
	2142	drawpipe.drawRoundRect(this, x, y, w, h, arcW, arcH);
	2143	} catch (InvalidPipeException e2) {
	2144	// Still catching the exception; we are not yet ready to
	2145	// validate the surfaceData correctly. Fail for now and
	2146	// try again next time around.
	2147	}
	2148	} finally {
	2149	surfaceData.markDirty();
	2150	}
	2151	}
	2152
	2153	public void fillRoundRect(int x, int y, int w, int h, int arcW, int arcH) {
	2154	try {
	2155	fillpipe.fillRoundRect(this, x, y, w, h, arcW, arcH);
	2156	} catch (InvalidPipeException e) {
	2157	revalidateAll();
	2158	try {
	2159	fillpipe.fillRoundRect(this, x, y, w, h, arcW, arcH);
	2160	} catch (InvalidPipeException e2) {
	2161	// Still catching the exception; we are not yet ready to
	2162	// validate the surfaceData correctly. Fail for now and
	2163	// try again next time around.
	2164	}
	2165	} finally {
	2166	surfaceData.markDirty();
	2167	}
	2168	}
	2169
	2170	public void drawOval(int x, int y, int w, int h) {
	2171	try {
	2172	drawpipe.drawOval(this, x, y, w, h);
	2173	} catch (InvalidPipeException e) {
	2174	revalidateAll();
	2175	try {
	2176	drawpipe.drawOval(this, x, y, w, h);
	2177	} catch (InvalidPipeException e2) {
	2178	// Still catching the exception; we are not yet ready to
	2179	// validate the surfaceData correctly. Fail for now and
	2180	// try again next time around.
	2181	}
	2182	} finally {
	2183	surfaceData.markDirty();
	2184	}
	2185	}
	2186
	2187	public void fillOval(int x, int y, int w, int h) {
	2188	try {
	2189	fillpipe.fillOval(this, x, y, w, h);
	2190	} catch (InvalidPipeException e) {
	2191	revalidateAll();
	2192	try {
	2193	fillpipe.fillOval(this, x, y, w, h);
	2194	} catch (InvalidPipeException e2) {
	2195	// Still catching the exception; we are not yet ready to
	2196	// validate the surfaceData correctly. Fail for now and
	2197	// try again next time around.
	2198	}
	2199	} finally {
	2200	surfaceData.markDirty();
	2201	}
	2202	}
	2203
	2204	public void drawArc(int x, int y, int w, int h,
	2205	int startAngl, int arcAngl) {
	2206	try {
	2207	drawpipe.drawArc(this, x, y, w, h, startAngl, arcAngl);
	2208	} catch (InvalidPipeException e) {
	2209	revalidateAll();
	2210	try {
	2211	drawpipe.drawArc(this, x, y, w, h, startAngl, arcAngl);
	2212	} catch (InvalidPipeException e2) {
	2213	// Still catching the exception; we are not yet ready to
	2214	// validate the surfaceData correctly. Fail for now and
	2215	// try again next time around.
	2216	}
	2217	} finally {
	2218	surfaceData.markDirty();
	2219	}
	2220	}
	2221
	2222	public void fillArc(int x, int y, int w, int h,
	2223	int startAngl, int arcAngl) {
	2224	try {
	2225	fillpipe.fillArc(this, x, y, w, h, startAngl, arcAngl);
	2226	} catch (InvalidPipeException e) {
	2227	revalidateAll();
	2228	try {
	2229	fillpipe.fillArc(this, x, y, w, h, startAngl, arcAngl);
	2230	} catch (InvalidPipeException e2) {
	2231	// Still catching the exception; we are not yet ready to
	2232	// validate the surfaceData correctly. Fail for now and
	2233	// try again next time around.
	2234	}
	2235	} finally {
	2236	surfaceData.markDirty();
	2237	}
	2238	}
	2239
	2240	public void drawPolyline(int xPoints[], int yPoints[], int nPoints) {
	2241	try {
	2242	drawpipe.drawPolyline(this, xPoints, yPoints, nPoints);
	2243	} catch (InvalidPipeException e) {
	2244	revalidateAll();
	2245	try {
	2246	drawpipe.drawPolyline(this, xPoints, yPoints, nPoints);
	2247	} catch (InvalidPipeException e2) {
	2248	// Still catching the exception; we are not yet ready to
	2249	// validate the surfaceData correctly. Fail for now and
	2250	// try again next time around.
	2251	}
	2252	} finally {
	2253	surfaceData.markDirty();
	2254	}
	2255	}
	2256
	2257	public void drawPolygon(int xPoints[], int yPoints[], int nPoints) {
	2258	try {
	2259	drawpipe.drawPolygon(this, xPoints, yPoints, nPoints);
	2260	} catch (InvalidPipeException e) {
	2261	revalidateAll();
	2262	try {
	2263	drawpipe.drawPolygon(this, xPoints, yPoints, nPoints);
	2264	} catch (InvalidPipeException e2) {
	2265	// Still catching the exception; we are not yet ready to
	2266	// validate the surfaceData correctly. Fail for now and
	2267	// try again next time around.
	2268	}
	2269	} finally {
	2270	surfaceData.markDirty();
	2271	}
	2272	}
	2273
	2274	public void fillPolygon(int xPoints[], int yPoints[], int nPoints) {
	2275	try {
	2276	fillpipe.fillPolygon(this, xPoints, yPoints, nPoints);
	2277	} catch (InvalidPipeException e) {
	2278	revalidateAll();
	2279	try {
	2280	fillpipe.fillPolygon(this, xPoints, yPoints, nPoints);
	2281	} catch (InvalidPipeException e2) {
	2282	// Still catching the exception; we are not yet ready to
	2283	// validate the surfaceData correctly. Fail for now and
	2284	// try again next time around.
	2285	}
	2286	} finally {
	2287	surfaceData.markDirty();
	2288	}
	2289	}
	2290
	2291	public void drawRect (int x, int y, int w, int h) {
	2292	try {
	2293	drawpipe.drawRect(this, x, y, w, h);
	2294	} catch (InvalidPipeException e) {
	2295	revalidateAll();
	2296	try {
	2297	drawpipe.drawRect(this, x, y, w, h);
	2298	} catch (InvalidPipeException e2) {
	2299	// Still catching the exception; we are not yet ready to
	2300	// validate the surfaceData correctly. Fail for now and
	2301	// try again next time around.
	2302	}
	2303	} finally {
	2304	surfaceData.markDirty();
	2305	}
	2306	}
	2307
	2308	public void fillRect (int x, int y, int w, int h) {
	2309	try {
	2310	fillpipe.fillRect(this, x, y, w, h);
	2311	} catch (InvalidPipeException e) {
	2312	revalidateAll();
	2313	try {
	2314	fillpipe.fillRect(this, x, y, w, h);
	2315	} catch (InvalidPipeException e2) {
	2316	// Still catching the exception; we are not yet ready to
	2317	// validate the surfaceData correctly. Fail for now and
	2318	// try again next time around.
	2319	}
	2320	} finally {
	2321	surfaceData.markDirty();
	2322	}
	2323	}
	2324
	2325	private void revalidateAll() {
	2326	try {
	2327	// REMIND: This locking needs to be done around the
	2328	// caller of this method so that the pipe stays valid
	2329	// long enough to call the new primitive.
	2330	// REMIND: No locking yet in screen SurfaceData objects!
	2331	// surfaceData.lock();
	2332	surfaceData = surfaceData.getReplacement();
	2333	if (surfaceData == null) {
	2334	surfaceData = NullSurfaceData.theInstance;
	2335	}
	2336
	2337	// this will recalculate the composite clip
	2338	setDevClip(surfaceData.getBounds());
	2339
	2340	if (paintState <= PAINT_ALPHACOLOR) {
	2341	validateColor();
	2342	}
	2343	if (composite instanceof XORComposite) {
	2344	Color c = ((XORComposite) composite).getXorColor();
	2345	setComposite(new XORComposite(c, surfaceData));
	2346	}
	2347	validatePipe();
	2348	} finally {
	2349	// REMIND: No locking yet in screen SurfaceData objects!
	2350	// surfaceData.unlock();
	2351	}
	2352	}
	2353
	2354	public void clearRect(int x, int y, int w, int h) {
	2355	// REMIND: has some "interesting" consequences if threads are
	2356	// not synchronized
	2357	Composite c = composite;
	2358	Paint p = paint;
	2359	setComposite(AlphaComposite.Src);
	2360	setColor(getBackground());
	2361	validatePipe();
	2362	fillRect(x, y, w, h);
	2363	setPaint(p);
	2364	setComposite(c);
	2365	}
	2366
	2367	/**
	2368	* Strokes the outline of a Path using the settings of the current
	2369	* graphics state. The rendering attributes applied include the
	2370	* clip, transform, paint or color, composite and stroke attributes.
	2371	* @param p The path to be drawn.
	2372	* @see #setStroke
	2373	* @see #setPaint
	2374	* @see java.awt.Graphics#setColor
	2375	* @see #transform
	2376	* @see #setTransform
	2377	* @see #clip
	2378	* @see #setClip
	2379	* @see #setComposite
	2380	*/
	2381	public void draw(Shape s) {
	2382	try {
	2383	shapepipe.draw(this, s);
	2384	} catch (InvalidPipeException e) {
	2385	revalidateAll();
	2386	try {
	2387	shapepipe.draw(this, s);
	2388	} catch (InvalidPipeException e2) {
	2389	// Still catching the exception; we are not yet ready to
	2390	// validate the surfaceData correctly. Fail for now and
	2391	// try again next time around.
	2392	}
	2393	} finally {
	2394	surfaceData.markDirty();
	2395	}
	2396	}
	2397
	2398
	2399	/**
	2400	* Fills the interior of a Path using the settings of the current
	2401	* graphics state. The rendering attributes applied include the
	2402	* clip, transform, paint or color, and composite.
	2403	* @see #setPaint
	2404	* @see java.awt.Graphics#setColor
	2405	* @see #transform
	2406	* @see #setTransform
	2407	* @see #setComposite
	2408	* @see #clip
	2409	* @see #setClip
	2410	*/
	2411	public void fill(Shape s) {
	2412	try {
	2413	shapepipe.fill(this, s);
	2414	} catch (InvalidPipeException e) {
	2415	revalidateAll();
	2416	try {
	2417	shapepipe.fill(this, s);
	2418	} catch (InvalidPipeException e2) {
	2419	// Still catching the exception; we are not yet ready to
	2420	// validate the surfaceData correctly. Fail for now and
	2421	// try again next time around.
	2422	}
	2423	} finally {
	2424	surfaceData.markDirty();
	2425	}
	2426	}
	2427
	2428	/**
	2429	* Returns true if the given AffineTransform is an integer
	2430	* translation.
	2431	*/
	2432	private static boolean isIntegerTranslation(AffineTransform xform) {
	2433	if (xform.isIdentity()) {
	2434	return true;
	2435	}
	2436	if (xform.getType() == AffineTransform.TYPE_TRANSLATION) {
	2437	double tx = xform.getTranslateX();
	2438	double ty = xform.getTranslateY();
	2439	return (tx == (int)tx && ty == (int)ty);
	2440	}
	2441	return false;
	2442	}
	2443
	2444	/**
	2445	* Returns the index of the tile corresponding to the supplied position
	2446	* given the tile grid offset and size along the same axis.
	2447	*/
	2448	private static int getTileIndex(int p, int tileGridOffset, int tileSize) {
	2449	p -= tileGridOffset;
	2450	if (p < 0) {
	2451	p += 1 - tileSize; // force round to -infinity (ceiling)
	2452	}
	2453	return p/tileSize;
	2454	}
	2455
	2456	/**
	2457	* Returns a rectangle in image coordinates that may be required
	2458	* in order to draw the given image into the given clipping region
	2459	* through a pair of AffineTransforms. In addition, horizontal and
	2460	* vertical padding factors for antialising and interpolation may
	2461	* be used.
	2462	*/
	2463	private static Rectangle getImageRegion(RenderedImage img,
	2464	Region compClip,
	2465	AffineTransform transform,
	2466	AffineTransform xform,
	2467	int padX, int padY) {
	2468	Rectangle imageRect =
	2469	new Rectangle(img.getMinX(), img.getMinY(),
	2470	img.getWidth(), img.getHeight());
	2471
	2472	Rectangle result = null;
	2473	try {
	2474	double p[] = new double[8];
	2475	p[0] = p[2] = compClip.getLoX();
	2476	p[4] = p[6] = compClip.getHiX();
	2477	p[1] = p[5] = compClip.getLoY();
	2478	p[3] = p[7] = compClip.getHiY();
	2479
	2480	// Inverse transform the output bounding rect
	2481	transform.inverseTransform(p, 0, p, 0, 4);
	2482	xform.inverseTransform(p, 0, p, 0, 4);
	2483
	2484	// Determine a bounding box for the inverse transformed region
	2485	double x0,x1,y0,y1;
	2486	x0 = x1 = p[0];
	2487	y0 = y1 = p[1];
	2488
	2489	for (int i = 2; i < 8; ) {
	2490	double pt = p[i++];
	2491	if (pt < x0) {
	2492	x0 = pt;
	2493	} else if (pt > x1) {
	2494	x1 = pt;
	2495	}
	2496	pt = p[i++];
	2497	if (pt < y0) {
	2498	y0 = pt;
	2499	} else if (pt > y1) {
	2500	y1 = pt;
	2501	}
	2502	}
	2503
	2504	// This is padding for anti-aliasing and such. It may
	2505	// be more than is needed.
	2506	int x = (int)x0 - padX;
	2507	int w = (int)(x1 - x0 + 2*padX);
	2508	int y = (int)y0 - padY;
	2509	int h = (int)(y1 - y0 + 2*padY);
	2510
	2511	Rectangle clipRect = new Rectangle(x,y,w,h);
	2512	result = clipRect.intersection(imageRect);
	2513	} catch (NoninvertibleTransformException nte) {
	2514	// Worst case bounds are the bounds of the image.
	2515	result = imageRect;
	2516	}
	2517
	2518	return result;
	2519	}
	2520
	2521	/**
	2522	* Draws an image, applying a transform from image space into user space
	2523	* before drawing.
	2524	* The transformation from user space into device space is done with
	2525	* the current transform in the Graphics2D.
	2526	* The given transformation is applied to the image before the
	2527	* transform attribute in the Graphics2D state is applied.
	2528	* The rendering attributes applied include the clip, transform,
	2529	* and composite attributes. Note that the result is
	2530	* undefined, if the given transform is noninvertible.
	2531	* @param img The image to be drawn. Does nothing if img is null.
	2532	* @param xform The transformation from image space into user space.
	2533	* @see #transform
	2534	* @see #setTransform
	2535	* @see #setComposite
	2536	* @see #clip
	2537	* @see #setClip
	2538	*/
	2539	public void drawRenderedImage(RenderedImage img,
	2540	AffineTransform xform) {
	2541
	2542	if (img == null) {
	2543	return;
	2544	}
	2545
	2546	// BufferedImage case: use a simple drawImage call
	2547	if (img instanceof BufferedImage) {
	2548	BufferedImage bufImg = (BufferedImage)img;
	2549	drawImage(bufImg,xform,null);
	2550	return;
	2551	}
	2552
	2553	// transformState tracks the state of transform and
	2554	// transX, transY contain the integer casts of the
	2555	// translation factors
	2556	boolean isIntegerTranslate =
	2557	(transformState <= TRANSFORM_INT_TRANSLATE) &&
	2558	isIntegerTranslation(xform);
	2559
	2560	// Include padding for interpolation/antialiasing if necessary
	2561	int pad = isIntegerTranslate ? 0 : 3;
	2562
	2563	// Determine the region of the image that may contribute to
	2564	// the clipped drawing area
	2565	Rectangle region = getImageRegion(img,
	2566	getCompClip(),
	2567	transform,
	2568	xform,
	2569	pad, pad);
	2570	if (region.width <= 0 \|\| region.height <= 0) {
	2571	return;
	2572	}
	2573
	2574	// Attempt to optimize integer translation of tiled images.
	2575	// Although theoretically we are O.K. if the concatenation of
	2576	// the user transform and the device transform is an integer
	2577	// translation, we'll play it safe and only optimize the case
	2578	// where both are integer translations.
	2579	if (isIntegerTranslate) {
	2580	// Use optimized code
	2581	// Note that drawTranslatedRenderedImage calls copyImage
	2582	// which takes the user space to device space transform into
	2583	// account, but we need to provide the image space to user space
	2584	// translations.
	2585
	2586	drawTranslatedRenderedImage(img, region,
	2587	(int) xform.getTranslateX(),
	2588	(int) xform.getTranslateY());
	2589	return;
	2590	}
	2591
	2592	// General case: cobble the necessary region into a single Raster
	2593	Raster raster = img.getData(region);
	2594
	2595	// Make a new Raster with the same contents as raster
	2596	// but starting at (0, 0). This raster is thus in the same
	2597	// coordinate system as the SampleModel of the original raster.
	2598	WritableRaster wRaster =
	2599	Raster.createWritableRaster(raster.getSampleModel(),
	2600	raster.getDataBuffer(),
	2601	null);
	2602
	2603	// If the original raster was in a different coordinate
	2604	// system than its SampleModel, we need to perform an
	2605	// additional translation in order to get the (minX, minY)
	2606	// pixel of raster to be pixel (0, 0) of wRaster. We also
	2607	// have to have the correct width and height.
	2608	int minX = raster.getMinX();
	2609	int minY = raster.getMinY();
	2610	int width = raster.getWidth();
	2611	int height = raster.getHeight();
	2612	int px = minX - raster.getSampleModelTranslateX();
	2613	int py = minY - raster.getSampleModelTranslateY();
	2614	if (px != 0 \|\| py != 0 \|\| width != wRaster.getWidth() \|\|
	2615	height != wRaster.getHeight()) {
	2616	wRaster =
	2617	wRaster.createWritableChild(px,
	2618	py,
	2619	width,
	2620	height,
	2621	0, 0,
	2622	null);
	2623	}
	2624
	2625	// Now we have a BufferedImage starting at (0, 0)
	2626	// with the same contents that started at (minX, minY)
	2627	// in raster. So we must draw the BufferedImage with a
	2628	// translation of (minX, minY).
	2629	AffineTransform transXform = (AffineTransform)xform.clone();
	2630	transXform.translate(minX, minY);
	2631
	2632	ColorModel cm = img.getColorModel();
	2633	BufferedImage bufImg = new BufferedImage(cm,
	2634	wRaster,
	2635	cm.isAlphaPremultiplied(),
	2636	null);
	2637	drawImage(bufImg, transXform, null);
	2638	}
	2639
	2640	/**
	2641	* Intersects <code>destRect</code> with <code>clip</code> and
	2642	* overwrites <code>destRect</code> with the result.
	2643	* Returns false if the intersection was empty, true otherwise.
	2644	*/
	2645	private boolean clipTo(Rectangle destRect, Rectangle clip) {
	2646	int x1 = Math.max(destRect.x, clip.x);
	2647	int x2 = Math.min(destRect.x + destRect.width, clip.x + clip.width);
	2648	int y1 = Math.max(destRect.y, clip.y);
	2649	int y2 = Math.min(destRect.y + destRect.height, clip.y + clip.height);
	2650	if (((x2 - x1) < 0) \|\| ((y2 - y1) < 0)) {
	2651	destRect.width = -1; // Set both just to be safe
	2652	destRect.height = -1;
	2653	return false;
	2654	} else {
	2655	destRect.x = x1;
	2656	destRect.y = y1;
	2657	destRect.width = x2 - x1;
	2658	destRect.height = y2 - y1;
	2659	return true;
	2660	}
	2661	}
	2662
	2663	/**
	2664	* Draw a portion of a RenderedImage tile-by-tile with a given
	2665	* integer image to user space translation. The user to
	2666	* device transform must also be an integer translation.
	2667	*/
	2668	private void drawTranslatedRenderedImage(RenderedImage img,
	2669	Rectangle region,
	2670	int i2uTransX,
	2671	int i2uTransY) {
	2672	// Cache tile grid info
	2673	int tileGridXOffset = img.getTileGridXOffset();
	2674	int tileGridYOffset = img.getTileGridYOffset();
	2675	int tileWidth = img.getTileWidth();
	2676	int tileHeight = img.getTileHeight();
	2677
	2678	// Determine the tile index extrema in each direction
	2679	int minTileX =
	2680	getTileIndex(region.x, tileGridXOffset, tileWidth);
	2681	int minTileY =
	2682	getTileIndex(region.y, tileGridYOffset, tileHeight);
	2683	int maxTileX =
	2684	getTileIndex(region.x + region.width - 1,
	2685	tileGridXOffset, tileWidth);
	2686	int maxTileY =
	2687	getTileIndex(region.y + region.height - 1,
	2688	tileGridYOffset, tileHeight);
	2689
	2690	// Create a single ColorModel to use for all BufferedImages
	2691	ColorModel colorModel = img.getColorModel();
	2692
	2693	// Reuse the same Rectangle for each iteration
	2694	Rectangle tileRect = new Rectangle();
	2695
	2696	for (int ty = minTileY; ty <= maxTileY; ty++) {
	2697	for (int tx = minTileX; tx <= maxTileX; tx++) {
	2698	// Get the current tile.
	2699	Raster raster = img.getTile(tx, ty);
	2700
	2701	// Fill in tileRect with the tile bounds
	2702	tileRect.x = tx*tileWidth + tileGridXOffset;
	2703	tileRect.y = ty*tileHeight + tileGridYOffset;
	2704	tileRect.width = tileWidth;
	2705	tileRect.height = tileHeight;
	2706
	2707	// Clip the tile against the image bounds and
	2708	// backwards mapped clip region
	2709	// The result can't be empty
	2710	clipTo(tileRect, region);
	2711
	2712	// Create a WritableRaster containing the tile
	2713	WritableRaster wRaster = null;
	2714	if (raster instanceof WritableRaster) {
	2715	wRaster = (WritableRaster)raster;
	2716	} else {
	2717	// Create a WritableRaster in the same coordinate system
	2718	// as the original raster.
	2719	wRaster =
	2720	Raster.createWritableRaster(raster.getSampleModel(),
	2721	raster.getDataBuffer(),
	2722	null);
	2723	}
	2724
	2725	// Translate wRaster to start at (0, 0) and to contain
	2726	// only the relevent portion of the tile
	2727	wRaster = wRaster.createWritableChild(tileRect.x, tileRect.y,
	2728	tileRect.width,
	2729	tileRect.height,
	2730	0, 0,
	2731	null);
	2732
	2733	// Wrap wRaster in a BufferedImage
	2734	BufferedImage bufImg =
	2735	new BufferedImage(colorModel,
	2736	wRaster,
	2737	colorModel.isAlphaPremultiplied(),
	2738	null);
	2739	// Now we have a BufferedImage starting at (0, 0) that
	2740	// represents data from a Raster starting at
	2741	// (tileRect.x, tileRect.y). Additionally, it needs
	2742	// to be translated by (i2uTransX, i2uTransY). We call
	2743	// copyImage to draw just the region of interest
	2744	// without needing to create a child image.
	2745	copyImage(bufImg, tileRect.x + i2uTransX,
	2746	tileRect.y + i2uTransY, 0, 0, tileRect.width,
	2747	tileRect.height, null, null);
	2748	}
	2749	}
	2750	}
	2751
	2752	public void drawRenderableImage(RenderableImage img,
	2753	AffineTransform xform) {
	2754
	2755	if (img == null) {
	2756	return;
	2757	}
	2758
	2759	AffineTransform pipeTransform = transform;
	2760	AffineTransform concatTransform = new AffineTransform(xform);
	2761	concatTransform.concatenate(pipeTransform);
	2762	AffineTransform reverseTransform;
	2763
	2764	RenderContext rc = new RenderContext(concatTransform);
	2765
	2766	try {
	2767	reverseTransform = pipeTransform.createInverse();
	2768	} catch (NoninvertibleTransformException nte) {
	2769	rc = new RenderContext(pipeTransform);
	2770	reverseTransform = new AffineTransform();
	2771	}
	2772
	2773	RenderedImage rendering = img.createRendering(rc);
	2774	drawRenderedImage(rendering,reverseTransform);
	2775	}
	2776
	2777
	2778
	2779	/*
	2780	* Transform the bounding box of the BufferedImage
	2781	*/
	2782	protected Rectangle transformBounds(Rectangle rect,
	2783	AffineTransform tx) {
	2784	if (tx.isIdentity()) {
	2785	return rect;
	2786	}
	2787
	2788	Shape s = transformShape(tx, rect);
	2789	return s.getBounds();
	2790	}
	2791
	2792	// text rendering methods
	2793	public void drawString(String str, int x, int y) {
	2794	if (str == null) {
	2795	throw new NullPointerException("String is null");
	2796	}
	2797
	2798	if (font.hasLayoutAttributes()) {
	2799	if (str.length() == 0) {
	2800	return;
	2801	}
	2802	new TextLayout(str, font, getFontRenderContext()).draw(this, x, y);
	2803	return;
	2804	}
	2805
	2806	try {
	2807	textpipe.drawString(this, str, x, y);
	2808	} catch (InvalidPipeException e) {
	2809	revalidateAll();
	2810	try {
	2811	textpipe.drawString(this, str, x, y);
	2812	} catch (InvalidPipeException e2) {
	2813	// Still catching the exception; we are not yet ready to
	2814	// validate the surfaceData correctly. Fail for now and
	2815	// try again next time around.
	2816	}
	2817	} finally {
	2818	surfaceData.markDirty();
	2819	}
	2820	}
	2821
	2822	public void drawString(String str, float x, float y) {
	2823	if (str == null) {
	2824	throw new NullPointerException("String is null");
	2825	}
	2826
	2827	if (font.hasLayoutAttributes()) {
	2828	if (str.length() == 0) {
	2829	return;
	2830	}
	2831	new TextLayout(str, font, getFontRenderContext()).draw(this, x, y);
	2832	return;
	2833	}
	2834
	2835	try {
	2836	textpipe.drawString(this, str, x, y);
	2837	} catch (InvalidPipeException e) {
	2838	revalidateAll();
	2839	try {
	2840	textpipe.drawString(this, str, x, y);
	2841	} catch (InvalidPipeException e2) {
	2842	// Still catching the exception; we are not yet ready to
	2843	// validate the surfaceData correctly. Fail for now and
	2844	// try again next time around.
	2845	}
	2846	} finally {
	2847	surfaceData.markDirty();
	2848	}
	2849	}
	2850
	2851	public void drawString(AttributedCharacterIterator iterator,
	2852	int x, int y) {
	2853	if (iterator == null) {
	2854	throw new NullPointerException("AttributedCharacterIterator is null");
	2855	}
	2856	if (iterator.getBeginIndex() == iterator.getEndIndex()) {
	2857	return; /* nothing to draw */
	2858	}
	2859	TextLayout tl = new TextLayout(iterator, getFontRenderContext());
	2860	tl.draw(this, (float) x, (float) y);
	2861	}
	2862
	2863	public void drawString(AttributedCharacterIterator iterator,
	2864	float x, float y) {
	2865	if (iterator == null) {
	2866	throw new NullPointerException("AttributedCharacterIterator is null");
	2867	}
	2868	if (iterator.getBeginIndex() == iterator.getEndIndex()) {
	2869	return; /* nothing to draw */
	2870	}
	2871	TextLayout tl = new TextLayout(iterator, getFontRenderContext());
	2872	tl.draw(this, x, y);
	2873	}
	2874
	2875	public void drawGlyphVector(GlyphVector gv, float x, float y)
	2876	{
	2877	if (gv == null) {
	2878	throw new NullPointerException("GlyphVector is null");
	2879	}
	2880
	2881	try {
	2882	textpipe.drawGlyphVector(this, gv, x, y);
	2883	} catch (InvalidPipeException e) {
	2884	revalidateAll();
	2885	try {
	2886	textpipe.drawGlyphVector(this, gv, x, y);
	2887	} catch (InvalidPipeException e2) {
	2888	// Still catching the exception; we are not yet ready to
	2889	// validate the surfaceData correctly. Fail for now and
	2890	// try again next time around.
	2891	}
	2892	} finally {
	2893	surfaceData.markDirty();
	2894	}
	2895	}
	2896
	2897	public void drawChars(char data[], int offset, int length, int x, int y) {
	2898
	2899	if (data == null) {
	2900	throw new NullPointerException("char data is null");
	2901	}
	2902	if (offset < 0 \|\| length < 0 \|\| offset + length > data.length) {
	2903	throw new ArrayIndexOutOfBoundsException("bad offset/length");
	2904	}
	2905	if (font.hasLayoutAttributes()) {
	2906	if (data.length == 0) {
	2907	return;
	2908	}
	2909	new TextLayout(new String(data, offset, length),
	2910	font, getFontRenderContext()).draw(this, x, y);
	2911	return;
	2912	}
	2913
	2914	try {
	2915	textpipe.drawChars(this, data, offset, length, x, y);
	2916	} catch (InvalidPipeException e) {
	2917	revalidateAll();
	2918	try {
	2919	textpipe.drawChars(this, data, offset, length, x, y);
	2920	} catch (InvalidPipeException e2) {
	2921	// Still catching the exception; we are not yet ready to
	2922	// validate the surfaceData correctly. Fail for now and
	2923	// try again next time around.
	2924	}
	2925	} finally {
	2926	surfaceData.markDirty();
	2927	}
	2928	}
	2929
	2930	public void drawBytes(byte data[], int offset, int length, int x, int y) {
	2931	if (data == null) {
	2932	throw new NullPointerException("byte data is null");
	2933	}
	2934	if (offset < 0 \|\| length < 0 \|\| offset + length > data.length) {
	2935	throw new ArrayIndexOutOfBoundsException("bad offset/length");
	2936	}
	2937	/* Byte data is interpreted as 8-bit ASCII. Re-use drawChars loops */
	2938	char chData[] = new char[length];
	2939	for (int i = length; i-- > 0; ) {
	2940	chData[i] = (char)(data[i+offset] & 0xff);
	2941	}
	2942	if (font.hasLayoutAttributes()) {
	2943	if (data.length == 0) {
	2944	return;
	2945	}
	2946	new TextLayout(new String(chData),
	2947	font, getFontRenderContext()).draw(this, x, y);
	2948	return;
	2949	}
	2950
	2951	try {
	2952	textpipe.drawChars(this, chData, 0, length, x, y);
	2953	} catch (InvalidPipeException e) {
	2954	revalidateAll();
	2955	try {
	2956	textpipe.drawChars(this, chData, 0, length, x, y);
	2957	} catch (InvalidPipeException e2) {
	2958	// Still catching the exception; we are not yet ready to
	2959	// validate the surfaceData correctly. Fail for now and
	2960	// try again next time around.
	2961	}
	2962	} finally {
	2963	surfaceData.markDirty();
	2964	}
	2965	}
	2966	// end of text rendering methods
	2967
	2968	/**
	2969	* Draws an image scaled to x,y,w,h in nonblocking mode with a
	2970	* callback object.
	2971	*/
	2972	public boolean drawImage(Image img, int x, int y, int width, int height,
	2973	ImageObserver observer) {
	2974	return drawImage(img, x, y, width, height, null, observer);
	2975	}
	2976
	2977	/**
	2978	* Not part of the advertised API but a useful utility method
	2979	* to call internally. This is for the case where we are
	2980	* drawing to/from given coordinates using a given width/height,
	2981	* but we guarantee that the weidth/height of the src and dest
	2982	* areas are equal (no scale needed).
	2983	*/
	2984	public boolean copyImage(Image img, int dx, int dy, int sx, int sy,
	2985	int width, int height, Color bgcolor,
	2986	ImageObserver observer) {
	2987	try {
	2988	return imagepipe.copyImage(this, img, dx, dy, sx, sy,
	2989	width, height, bgcolor, observer);
	2990	} catch (InvalidPipeException e) {
	2991	revalidateAll();
	2992	try {
	2993	return imagepipe.copyImage(this, img, dx, dy, sx, sy,
	2994	width, height, bgcolor, observer);
	2995	} catch (InvalidPipeException e2) {
	2996	// Still catching the exception; we are not yet ready to
	2997	// validate the surfaceData correctly. Fail for now and
	2998	// try again next time around.
	2999	return false;
	3000	}
	3001	} finally {
	3002	surfaceData.markDirty();
	3003	}
	3004	}
	3005
	3006	/**
	3007	* Draws an image scaled to x,y,w,h in nonblocking mode with a
	3008	* solid background color and a callback object.
	3009	*/
	3010	public boolean drawImage(Image img, int x, int y, int width, int height,
	3011	Color bg, ImageObserver observer) {
	3012
	3013	if (img == null) {
	3014	return true;
	3015	}
	3016
	3017	if ((width == 0) \|\| (height == 0)) {
	3018	return true;
	3019	}
	3020	if (width == img.getWidth(null) && height == img.getHeight(null)) {
	3021	return copyImage(img, x, y, 0, 0, width, height, bg, observer);
	3022	}
	3023
	3024	try {
	3025	return imagepipe.scaleImage(this, img, x, y, width, height,
	3026	bg, observer);
	3027	} catch (InvalidPipeException e) {
	3028	revalidateAll();
	3029	try {
	3030	return imagepipe.scaleImage(this, img, x, y, width, height,
	3031	bg, observer);
	3032	} catch (InvalidPipeException e2) {
	3033	// Still catching the exception; we are not yet ready to
	3034	// validate the surfaceData correctly. Fail for now and
	3035	// try again next time around.
	3036	return false;
	3037	}
	3038	} finally {
	3039	surfaceData.markDirty();
	3040	}
	3041	}
	3042
	3043	/**
	3044	* Draws an image at x,y in nonblocking mode.
	3045	*/
	3046	public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
	3047	return drawImage(img, x, y, null, observer);
	3048	}
	3049
	3050	/**
	3051	* Draws an image at x,y in nonblocking mode with a solid background
	3052	* color and a callback object.
	3053	*/
	3054	public boolean drawImage(Image img, int x, int y, Color bg,
	3055	ImageObserver observer) {
	3056
	3057	if (img == null) {
	3058	return true;
	3059	}
	3060
	3061	try {
	3062	return imagepipe.copyImage(this, img, x, y, bg, observer);
	3063	} catch (InvalidPipeException e) {
	3064	revalidateAll();
	3065	try {
	3066	return imagepipe.copyImage(this, img, x, y, bg, observer);
	3067	} catch (InvalidPipeException e2) {
	3068	// Still catching the exception; we are not yet ready to
	3069	// validate the surfaceData correctly. Fail for now and
	3070	// try again next time around.
	3071	return false;
	3072	}
	3073	} finally {
	3074	surfaceData.markDirty();
	3075	}
	3076	}
	3077
	3078	/**
	3079	* Draws a subrectangle of an image scaled to a destination rectangle
	3080	* in nonblocking mode with a callback object.
	3081	*/
	3082	public boolean drawImage(Image img,
	3083	int dx1, int dy1, int dx2, int dy2,
	3084	int sx1, int sy1, int sx2, int sy2,
	3085	ImageObserver observer) {
	3086	return drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
	3087	observer);
	3088	}
	3089
	3090	/**
	3091	* Draws a subrectangle of an image scaled to a destination rectangle in
	3092	* nonblocking mode with a solid background color and a callback object.
	3093	*/
	3094	public boolean drawImage(Image img,
	3095	int dx1, int dy1, int dx2, int dy2,
	3096	int sx1, int sy1, int sx2, int sy2,
	3097	Color bgcolor, ImageObserver observer) {
	3098
	3099	if (img == null) {
	3100	return true;
	3101	}
	3102
	3103	if (dx1 == dx2 \|\| dy1 == dy2 \|\|
	3104	sx1 == sx2 \|\| sy1 == sy2)
	3105	{
	3106	return true;
	3107	}
	3108
	3109	if (((sx2 - sx1) == (dx2 - dx1)) &&
	3110	((sy2 - sy1) == (dy2 - dy1)))
	3111	{
	3112	// Not a scale - forward it to a copy routine
	3113	int srcX, srcY, dstX, dstY, width, height;
	3114	if (sx2 > sx1) {
	3115	width = sx2 - sx1;
	3116	srcX = sx1;
	3117	dstX = dx1;
	3118	} else {
	3119	width = sx1 - sx2;
	3120	srcX = sx2;
	3121	dstX = dx2;
	3122	}
	3123	if (sy2 > sy1) {
	3124	height = sy2-sy1;
	3125	srcY = sy1;
	3126	dstY = dy1;
	3127	} else {
	3128	height = sy1-sy2;
	3129	srcY = sy2;
	3130	dstY = dy2;
	3131	}
	3132	return copyImage(img, dstX, dstY, srcX, srcY,
	3133	width, height, bgcolor, observer);
	3134	}
	3135
	3136	try {
	3137	return imagepipe.scaleImage(this, img, dx1, dy1, dx2, dy2,
	3138	sx1, sy1, sx2, sy2, bgcolor,
	3139	observer);
	3140	} catch (InvalidPipeException e) {
	3141	revalidateAll();
	3142	try {
	3143	return imagepipe.scaleImage(this, img, dx1, dy1, dx2, dy2,
	3144	sx1, sy1, sx2, sy2, bgcolor,
	3145	observer);
	3146	} catch (InvalidPipeException e2) {
	3147	// Still catching the exception; we are not yet ready to
	3148	// validate the surfaceData correctly. Fail for now and
	3149	// try again next time around.
	3150	return false;
	3151	}
	3152	} finally {
	3153	surfaceData.markDirty();
	3154	}
	3155	}
	3156
	3157	/**
	3158	* Draw an image, applying a transform from image space into user space
	3159	* before drawing.
	3160	* The transformation from user space into device space is done with
	3161	* the current transform in the Graphics2D.
	3162	* The given transformation is applied to the image before the
	3163	* transform attribute in the Graphics2D state is applied.
	3164	* The rendering attributes applied include the clip, transform,
	3165	* paint or color and composite attributes. Note that the result is
	3166	* undefined, if the given transform is non-invertible.
	3167	* @param img The image to be drawn.
	3168	* @param xform The transformation from image space into user space.
	3169	* @param observer The image observer to be notified on the image producing
	3170	* progress.
	3171	* @see #transform
	3172	* @see #setComposite
	3173	* @see #setClip
	3174	*/
	3175	public boolean drawImage(Image img,
	3176	AffineTransform xform,
	3177	ImageObserver observer) {
	3178
	3179	if (img == null) {
	3180	return true;
	3181	}
	3182
	3183	if (xform == null \|\| xform.isIdentity()) {
	3184	return drawImage(img, 0, 0, null, observer);
	3185	}
	3186
	3187	try {
	3188	return imagepipe.transformImage(this, img, xform, observer);
	3189	} catch (InvalidPipeException e) {
	3190	revalidateAll();
	3191	try {
	3192	return imagepipe.transformImage(this, img, xform, observer);
	3193	} catch (InvalidPipeException e2) {
	3194	// Still catching the exception; we are not yet ready to
	3195	// validate the surfaceData correctly. Fail for now and
	3196	// try again next time around.
	3197	return false;
	3198	}
	3199	} finally {
	3200	surfaceData.markDirty();
	3201	}
	3202	}
	3203
	3204	public void drawImage(BufferedImage bImg,
	3205	BufferedImageOp op,
	3206	int x,
	3207	int y) {
	3208
	3209	if (bImg == null) {
	3210	return;
	3211	}
	3212
	3213	try {
	3214	imagepipe.transformImage(this, bImg, op, x, y);
	3215	} catch (InvalidPipeException e) {
	3216	revalidateAll();
	3217	try {
	3218	imagepipe.transformImage(this, bImg, op, x, y);
	3219	} catch (InvalidPipeException e2) {
	3220	// Still catching the exception; we are not yet ready to
	3221	// validate the surfaceData correctly. Fail for now and
	3222	// try again next time around.
	3223	}
	3224	} finally {
	3225	surfaceData.markDirty();
	3226	}
	3227	}
	3228
	3229	/**
	3230	* Get the rendering context of the font
	3231	* within this Graphics2D context.
	3232	*/
	3233	public FontRenderContext getFontRenderContext() {
	3234	if (cachedFRC == null) {
	3235	int aahint = textAntialiasHint;
	3236	if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT &&
	3237	antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
	3238	aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
	3239	}
	3240	// Translation components should be excluded from the FRC transform
	3241	AffineTransform tx = null;
	3242	if (transformState >= TRANSFORM_TRANSLATESCALE) {
	3243	if (transform.getTranslateX() == 0 &&
	3244	transform.getTranslateY() == 0) {
	3245	tx = transform;
	3246	} else {
	3247	tx = new AffineTransform(transform.getScaleX(),
	3248	transform.getShearY(),
	3249	transform.getShearX(),
	3250	transform.getScaleY(),
	3251	0, 0);
	3252	}
	3253	}
	3254	cachedFRC = new FontRenderContext(tx,
	3255	SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING, aahint),
	3256	SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
	3257	fractionalMetricsHint));
	3258	}
	3259	return cachedFRC;
	3260	}
	3261	private FontRenderContext cachedFRC;
	3262
	3263	/**
	3264	* This object has no resources to dispose of per se, but the
	3265	* doc comments for the base method in java.awt.Graphics imply
	3266	* that this object will not be useable after it is disposed.
	3267	* So, we sabotage the object to prevent further use to prevent
	3268	* developers from relying on behavior that may not work on
	3269	* other, less forgiving, VMs that really need to dispose of
	3270	* resources.
	3271	*/
	3272	public void dispose() {
	3273	surfaceData = NullSurfaceData.theInstance;
	3274	invalidatePipe();
	3275	}
	3276
	3277	/**
	3278	* Graphics has a finalize method that automatically calls dispose()
	3279	* for subclasses. For SunGraphics2D we do not need to be finalized
	3280	* so that method simply causes us to be enqueued on the Finalizer
	3281	* queues for no good reason. Unfortunately, that method and
	3282	* implementation are now considered part of the public contract
	3283	* of that base class so we can not remove or gut the method.
	3284	* We override it here with an empty method and the VM is smart
	3285	* enough to know that if our override is empty then it should not
	3286	* mark us as finalizeable.
	3287	*/
	3288	public void finalize() {
	3289	// DO NOT REMOVE THIS METHOD
	3290	}
	3291
	3292	/**
	3293	* Returns destination that this Graphics renders to. This could be
	3294	* either an Image or a Component; subclasses of SurfaceData are
	3295	* responsible for returning the appropriate object.
	3296	*/
	3297	public Object getDestination() {
	3298	return surfaceData.getDestination();
	3299	}
	3300
	3301	/**
	3302	* {@inheritDoc}
	3303	*
	3304	* @see sun.java2d.DestSurfaceProvider#getDestSurface
	3305	*/
	3306	@Override
	3307	public Surface getDestSurface() {
	3308	return surfaceData;
	3309	}
	3310	}

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

Binary file not shown.

java/pkg/sun/java2d/SunGraphicsEnvironment.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SunGraphicsEnvironment.java+337−0

@@ -0,0 +1,337 @@
	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;
	27
	28	import java.awt.Color;
	29	import java.awt.Font;
	30	import java.awt.Graphics2D;
	31	import java.awt.GraphicsConfiguration;
	32	import java.awt.GraphicsDevice;
	33	import java.awt.GraphicsEnvironment;
	34	import java.awt.Insets;
	35	import java.awt.Rectangle;
	36	import java.awt.Toolkit;
	37	import java.awt.font.TextAttribute;
	38	import java.awt.image.BufferedImage;
	39	import java.awt.peer.ComponentPeer;
	40	import java.io.BufferedReader;
	41	import java.io.File;
	42	import java.io.FileInputStream;
	43	import java.io.FilenameFilter;
	44	import java.io.InputStreamReader;
	45	import java.io.IOException;
	46	import java.text.AttributedCharacterIterator;
	47	import java.util.ArrayList;
	48	import java.util.HashSet;
	49	import java.util.Iterator;
	50	import java.util.Locale;
	51	import java.util.Map;
	52	import java.util.NoSuchElementException;
	53	import java.util.Set;
	54	import java.util.StringTokenizer;
	55	import java.util.TreeMap;
	56	import java.util.Vector;
	57	import java.util.concurrent.ConcurrentHashMap;
	58	import sun.awt.AppContext;
	59	import sun.awt.DisplayChangedListener;
	60	import sun.awt.FontConfiguration;
	61	import sun.awt.SunDisplayChanger;
	62	import sun.font.CompositeFontDescriptor;
	63	import sun.font.Font2D;
	64	import sun.font.FontManager;
	65	import sun.font.FontManagerFactory;
	66	import sun.font.FontManagerForSGE;
	67	import sun.font.NativeFont;
	68
	69	/**
	70	* This is an implementation of a GraphicsEnvironment object for the
	71	* default local GraphicsEnvironment.
	72	*
	73	* @see GraphicsDevice
	74	* @see GraphicsConfiguration
	75	*/
	76	public abstract class SunGraphicsEnvironment extends GraphicsEnvironment
	77	implements DisplayChangedListener {
	78
	79	public static boolean isOpenSolaris;
	80	private static Font defaultFont;
	81
	82	public SunGraphicsEnvironment() {
	83	java.security.AccessController.doPrivileged(
	84	new java.security.PrivilegedAction() {
	85	public Object run() {
	86	String version = System.getProperty("os.version", "0.0");
	87	try {
	88	float ver = Float.parseFloat(version);
	89	if (ver > 5.10f) {
	90	File f = new File("/etc/release");
	91	FileInputStream fis = new FileInputStream(f);
	92	InputStreamReader isr
	93	= new InputStreamReader(fis, "ISO-8859-1");
	94	BufferedReader br = new BufferedReader(isr);
	95	String line = br.readLine();
	96	if (line.indexOf("OpenSolaris") >= 0) {
	97	isOpenSolaris = true;
	98	} else {
	99	/* We are using isOpenSolaris as meaning
	100	* we know the Solaris commercial fonts aren't
	101	* present. "Solaris Next" (03/10) did not
	102	* include these even though its was not
	103	* OpenSolaris. Need to revisit how this is
	104	* handled but for now as in 6ux, we'll use
	105	* the test for a standard font resource as
	106	* being an indicator as to whether we need
	107	* to treat this as OpenSolaris from a font
	108	* config perspective.
	109	*/
	110	String courierNew =
	111	"/usr/openwin/lib/X11/fonts/TrueType/CourierNew.ttf";
	112	File courierFile = new File(courierNew);
	113	isOpenSolaris = !courierFile.exists();
	114	}
	115	fis.close();
	116	}
	117	} catch (Exception e) {
	118	}
	119
	120	/* Establish the default font to be used by SG2D etc */
	121	defaultFont = new Font(Font.DIALOG, Font.PLAIN, 12);
	122
	123	return null;
	124	}
	125	});
	126	}
	127
	128	protected GraphicsDevice[] screens;
	129
	130	/**
	131	* Returns an array of all of the screen devices.
	132	*/
	133	public synchronized GraphicsDevice[] getScreenDevices() {
	134	GraphicsDevice[] ret = screens;
	135	if (ret == null) {
	136	int num = getNumScreens();
	137	ret = new GraphicsDevice[num];
	138	for (int i = 0; i < num; i++) {
	139	ret[i] = makeScreenDevice(i);
	140	}
	141	screens = ret;
	142	}
	143	return ret;
	144	}
	145
	146	/**
	147	* Returns the number of screen devices of this graphics environment.
	148	*
	149	* @return the number of screen devices of this graphics environment
	150	*/
	151	protected abstract int getNumScreens();
	152
	153	/**
	154	* Create and return the screen device with the specified number. The
	155	* device with number <code>0</code> will be the default device (returned
	156	* by {@link #getDefaultScreenDevice()}.
	157	*
	158	* @param screennum the number of the screen to create
	159	*
	160	* @return the created screen device
	161	*/
	162	protected abstract GraphicsDevice makeScreenDevice(int screennum);
	163
	164	/**
	165	* Returns the default screen graphics device.
	166	*/
	167	public GraphicsDevice getDefaultScreenDevice() {
	168	return getScreenDevices()[0];
	169	}
	170
	171	/**
	172	* Returns a Graphics2D object for rendering into the
	173	* given BufferedImage.
	174	* @throws NullPointerException if BufferedImage argument is null
	175	*/
	176	public Graphics2D createGraphics(BufferedImage img) {
	177	if (img == null) {
	178	throw new NullPointerException("BufferedImage cannot be null");
	179	}
	180	SurfaceData sd = SurfaceData.getPrimarySurfaceData(img);
	181	return new SunGraphics2D(sd, Color.white, Color.black, defaultFont);
	182	}
	183
	184	public static FontManagerForSGE getFontManagerForSGE() {
	185	FontManager fm = FontManagerFactory.getInstance();
	186	return (FontManagerForSGE) fm;
	187	}
	188
	189	/* Modifies the behaviour of a subsequent call to preferLocaleFonts()
	190	* to use Mincho instead of Gothic for dialoginput in JA locales
	191	* on windows. Not needed on other platforms.
	192	*
	193	* DO NOT MOVE OR RENAME OR OTHERWISE ALTER THIS METHOD.
	194	* ITS USED BY SOME NON-JRE INTERNAL CODE.
	195	*/
	196	public static void useAlternateFontforJALocales() {
	197	getFontManagerForSGE().useAlternateFontforJALocales();
	198	}
	199
	200	/**
	201	* Returns all fonts available in this environment.
	202	*/
	203	public Font[] getAllFonts() {
	204	FontManagerForSGE fm = getFontManagerForSGE();
	205	Font[] installedFonts = fm.getAllInstalledFonts();
	206	Font[] created = fm.getCreatedFonts();
	207	if (created == null \|\| created.length == 0) {
	208	return installedFonts;
	209	} else {
	210	int newlen = installedFonts.length + created.length;
	211	Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
	212	System.arraycopy(created, 0, fonts,
	213	installedFonts.length, created.length);
	214	return fonts;
	215	}
	216	}
	217
	218	public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
	219	FontManagerForSGE fm = getFontManagerForSGE();
	220	String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
	221	/* Use a new TreeMap as used in getInstalledFontFamilyNames
	222	* and insert all the keys in lower case, so that the sort order
	223	* is the same as the installed families. This preserves historical
	224	* behaviour and inserts new families in the right place.
	225	* It would have been marginally more efficient to directly obtain
	226	* the tree map and just insert new entries, but not so much as
	227	* to justify the extra internal interface.
	228	*/
	229	TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
	230	if (map == null \|\| map.size() == 0) {
	231	return installed;
	232	} else {
	233	for (int i=0; i<installed.length; i++) {
	234	map.put(installed[i].toLowerCase(requestedLocale),
	235	installed[i]);
	236	}
	237	String[] retval = new String[map.size()];
	238	Object [] keyNames = map.keySet().toArray();
	239	for (int i=0; i < keyNames.length; i++) {
	240	retval[i] = (String)map.get(keyNames[i]);
	241	}
	242	return retval;
	243	}
	244	}
	245
	246	public String[] getAvailableFontFamilyNames() {
	247	return getAvailableFontFamilyNames(Locale.getDefault());
	248	}
	249
	250	/**
	251	* Return the bounds of a GraphicsDevice, less its screen insets.
	252	* See also java.awt.GraphicsEnvironment.getUsableBounds();
	253	*/
	254	public static Rectangle getUsableBounds(GraphicsDevice gd) {
	255	GraphicsConfiguration gc = gd.getDefaultConfiguration();
	256	Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
	257	Rectangle usableBounds = gc.getBounds();
	258
	259	usableBounds.x += insets.left;
	260	usableBounds.y += insets.top;
	261	usableBounds.width -= (insets.left + insets.right);
	262	usableBounds.height -= (insets.top + insets.bottom);
	263
	264	return usableBounds;
	265	}
	266
	267	/**
	268	* From the DisplayChangedListener interface; called
	269	* when the display mode has been changed.
	270	*/
	271	public void displayChanged() {
	272	// notify screens in device array to do display update stuff
	273	for (GraphicsDevice gd : getScreenDevices()) {
	274	if (gd instanceof DisplayChangedListener) {
	275	((DisplayChangedListener) gd).displayChanged();
	276	}
	277	}
	278
	279	// notify SunDisplayChanger list (e.g. VolatileSurfaceManagers and
	280	// SurfaceDataProxies) about the display change event
	281	displayChanger.notifyListeners();
	282	}
	283
	284	/**
	285	* Part of the DisplayChangedListener interface:
	286	* propagate this event to listeners
	287	*/
	288	public void paletteChanged() {
	289	displayChanger.notifyPaletteChanged();
	290	}
	291
	292	/**
	293	* Returns true when the display is local, false for remote displays.
	294	*
	295	* @return true when the display is local, false for remote displays
	296	*/
	297	public abstract boolean isDisplayLocal();
	298
	299	/*
	300	* ----DISPLAY CHANGE SUPPORT----
	301	*/
	302
	303	protected SunDisplayChanger displayChanger = new SunDisplayChanger();
	304
	305	/**
	306	* Add a DisplayChangeListener to be notified when the display settings
	307	* are changed.
	308	*/
	309	public void addDisplayChangedListener(DisplayChangedListener client) {
	310	displayChanger.add(client);
	311	}
	312
	313	/**
	314	* Remove a DisplayChangeListener from Win32GraphicsEnvironment
	315	*/
	316	public void removeDisplayChangedListener(DisplayChangedListener client) {
	317	displayChanger.remove(client);
	318	}
	319
	320	/*
	321	* ----END DISPLAY CHANGE SUPPORT----
	322	*/
	323
	324	/**
	325	* Returns true if FlipBufferStrategy with COPIED buffer contents
	326	* is preferred for this peer's GraphicsConfiguration over
	327	* BlitBufferStrategy, false otherwise.
	328	*
	329	* The reason FlipBS could be preferred is that in some configurations
	330	* an accelerated copy to the screen is supported (like Direct3D 9)
	331	*
	332	* @return true if flip strategy should be used, false otherwise
	333	*/
	334	public boolean isFlipStrategyPreferred(ComponentPeer peer) {
	335	return false;
	336	}
	337	}

java/pkg/sun/java2d/Surface.class+0−0

Binary file not shown.

java/pkg/sun/java2d/Surface.java+34−0

@@ -0,0 +1,34 @@
	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;
	27
	28	/**
	29	* This is a tag interface for a surface.
	30	* @see sun.java2d.SurfaceData
	31	* @see sun.java2d.pipe.hw.AccelSurface
	32	*/
	33	public interface Surface {
	34	}

java/pkg/sun/java2d/SurfaceData$PixelToPgramLoopConverter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SurfaceData$PixelToShapeLoopConverter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SurfaceData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SurfaceData.java+1060−0

@@ -0,0 +1,1060 @@
	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;
	27
	28	import java.awt.Color;
	29	import java.awt.Rectangle;
	30	import java.awt.Transparency;
	31	import java.awt.GraphicsConfiguration;
	32	import java.awt.Image;
	33	import java.awt.image.ColorModel;
	34	import java.awt.image.IndexColorModel;
	35	import java.awt.image.Raster;
	36
	37	import sun.java2d.loops.RenderCache;
	38	import sun.java2d.loops.RenderLoops;
	39	import sun.java2d.loops.CompositeType;
	40	import sun.java2d.loops.SurfaceType;
	41	import sun.java2d.loops.MaskFill;
	42	import sun.java2d.loops.DrawLine;
	43	import sun.java2d.loops.FillRect;
	44	import sun.java2d.loops.DrawRect;
	45	import sun.java2d.loops.DrawPolygons;
	46	import sun.java2d.loops.DrawPath;
	47	import sun.java2d.loops.FillPath;
	48	import sun.java2d.loops.FillSpans;
	49	import sun.java2d.loops.FillParallelogram;
	50	import sun.java2d.loops.DrawParallelogram;
	51	import sun.java2d.loops.FontInfo;
	52	import sun.java2d.loops.DrawGlyphList;
	53	import sun.java2d.loops.DrawGlyphListAA;
	54	import sun.java2d.loops.DrawGlyphListLCD;
	55	import sun.java2d.pipe.LoopPipe;
	56	import sun.java2d.pipe.ShapeDrawPipe;
	57	import sun.java2d.pipe.ParallelogramPipe;
	58	import sun.java2d.pipe.CompositePipe;
	59	import sun.java2d.pipe.GeneralCompositePipe;
	60	import sun.java2d.pipe.SpanClipRenderer;
	61	import sun.java2d.pipe.SpanShapeRenderer;
	62	import sun.java2d.pipe.AAShapePipe;
	63	import sun.java2d.pipe.AlphaPaintPipe;
	64	import sun.java2d.pipe.AlphaColorPipe;
	65	import sun.java2d.pipe.PixelToShapeConverter;
	66	import sun.java2d.pipe.PixelToParallelogramConverter;
	67	import sun.java2d.pipe.TextPipe;
	68	import sun.java2d.pipe.TextRenderer;
	69	import sun.java2d.pipe.AATextRenderer;
	70	import sun.java2d.pipe.LCDTextRenderer;
	71	import sun.java2d.pipe.SolidTextRenderer;
	72	import sun.java2d.pipe.OutlineTextRenderer;
	73	import sun.java2d.pipe.DrawImagePipe;
	74	import sun.java2d.pipe.DrawImage;
	75	import sun.awt.SunHints;
	76	import sun.awt.image.SurfaceManager;
	77	import sun.java2d.pipe.LoopBasedPipe;
	78
	79	/**
	80	* This class provides various pieces of information relevant to a
	81	* particular drawing surface. The information obtained from this
	82	* object describes the pixels of a particular instance of a drawing
	83	* surface and can only be shared among the various graphics objects
	84	* that target the same BufferedImage or the same screen Component.
	85	* <p>
	86	* Each SurfaceData object holds a StateTrackableDelegate object
	87	* which tracks both changes to the content of the pixels of this
	88	* surface and changes to the overall state of the pixels - such
	89	* as becoming invalid or losing the surface. The delegate is
	90	* marked "dirty" whenever the setSurfaceLost() or invalidate()
	91	* methods are called and should also be marked "dirty" by the
	92	* rendering pipelines whenever they modify the pixels of this
	93	* SurfaceData.
	94	* <p>
	95	* If you get a StateTracker from a SurfaceData and it reports
	96	* that it is still "current", then you can trust that the pixels
	97	* have not changed and that the SurfaceData is still valid and
	98	* has not lost its underlying storage (surfaceLost) since you
	99	* retrieved the tracker.
	100	*/
	101	public abstract class SurfaceData
	102	implements Transparency, DisposerTarget, StateTrackable, Surface
	103	{
	104	private long pData;
	105	private boolean valid;
	106	private boolean surfaceLost; // = false;
	107	private SurfaceType surfaceType;
	108	private ColorModel colorModel;
	109
	110	private Object disposerReferent = new Object();
	111
	112	private static native void initIDs();
	113
	114	private Object blitProxyKey;
	115	private StateTrackableDelegate stateDelegate;
	116
	117	static {
	118	initIDs();
	119	}
	120
	121	protected SurfaceData(SurfaceType surfaceType, ColorModel cm) {
	122	this(State.STABLE, surfaceType, cm);
	123	}
	124
	125	protected SurfaceData(State state, SurfaceType surfaceType, ColorModel cm) {
	126	this(StateTrackableDelegate.createInstance(state), surfaceType, cm);
	127	}
	128
	129	protected SurfaceData(StateTrackableDelegate trackable,
	130	SurfaceType surfaceType, ColorModel cm)
	131	{
	132	this.stateDelegate = trackable;
	133	this.colorModel = cm;
	134	this.surfaceType = surfaceType;
	135	valid = true;
	136	}
	137
	138	protected SurfaceData(State state) {
	139	this.stateDelegate = StateTrackableDelegate.createInstance(state);
	140	valid = true;
	141	}
	142
	143	/**
	144	* Subclasses can set a "blit proxy key" which will be used
	145	* along with the SurfaceManager.getCacheData() mechanism to
	146	* store acceleration-compatible cached copies of source images.
	147	* This key is a "tag" used to identify which cached copies
	148	* are compatible with this destination SurfaceData.
	149	* The getSourceSurfaceData() method uses this key to manage
	150	* cached copies of a source image as described below.
	151	* <p>
	152	* The Object used as this key should be as unique as it needs
	153	* to be to ensure that multiple acceleratible destinations can
	154	* each store their cached copies separately under different keys
	155	* without interfering with each other or getting back the wrong
	156	* cached copy.
	157	* <p>
	158	* Many acceleratable SurfaceData objects can use their own
	159	* GraphicsConfiguration as their proxy key as the GC object will
	160	* typically be unique to a given screen and pixel format, but
	161	* other rendering destinations may have more or less stringent
	162	* sharing requirements. For instance, X11 pixmaps can be
	163	* shared on a given screen by any GraphicsConfiguration that
	164	* has the same depth and SurfaceType. Multiple such GCs with
	165	* the same depth and SurfaceType can exist per screen so storing
	166	* a different cached proxy for each would be a waste. One can
	167	* imagine platforms where a single cached copy can be created
	168	* and shared across all screens and pixel formats - such
	169	* implementations could use a single heavily shared key Object.
	170	*/
	171	protected void setBlitProxyKey(Object key) {
	172	// Caching is effectively disabled if we never have a proxy key
	173	// since the getSourceSurfaceData() method only does caching
	174	// if the key is not null.
	175	if (SurfaceDataProxy.isCachingAllowed()) {
	176	this.blitProxyKey = key;
	177	}
	178	}
	179
	180	/**
	181	* This method is called on a destination SurfaceData to choose
	182	* the best SurfaceData from a source Image for an imaging
	183	* operation, with help from its SurfaceManager.
	184	* The method may determine that the default SurfaceData was
	185	* really the best choice in the first place, or it may decide
	186	* to use a cached surface. Some general decisions about whether
	187	* acceleration is enabled are made by this method, but any
	188	* decision based on the type of the source image is made in
	189	* the makeProxyFor method below when it comes up with the
	190	* appropriate SurfaceDataProxy instance.
	191	* The parameters describe the type of imaging operation being performed.
	192	* <p>
	193	* If a blitProxyKey was supplied by the subclass then it is
	194	* used to potentially override the choice of source SurfaceData.
	195	* The outline of this process is:
	196	* <ol>
	197	* <li> Image pipeline asks destSD to find an appropriate
	198	* srcSD for a given source Image object.
	199	* <li> destSD gets the SurfaceManager of the source Image
	200	* and first retrieves the default SD from it using
	201	* getPrimarySurfaceData()
	202	* <li> destSD uses its "blit proxy key" (if set) to look for
	203	* some cached data stored in the source SurfaceManager
	204	* <li> If the cached data is null then makeProxyFor() is used
	205	* to create some cached data which is stored back in the
	206	* source SurfaceManager under the same key for future uses.
	207	* <li> The cached data will be a SurfaceDataProxy object.
	208	* <li> The SurfaceDataProxy object is then consulted to
	209	* return a replacement SurfaceData object (typically
	210	* a cached copy if appropriate, or the original if not).
	211	* </ol>
	212	*/
	213	public SurfaceData getSourceSurfaceData(Image img,
	214	int txtype,
	215	CompositeType comp,
	216	Color bgColor)
	217	{
	218	SurfaceManager srcMgr = SurfaceManager.getManager(img);
	219	SurfaceData srcData = srcMgr.getPrimarySurfaceData();
	220	if (img.getAccelerationPriority() > 0.0f &&
	221	blitProxyKey != null)
	222	{
	223	SurfaceDataProxy sdp =
	224	(SurfaceDataProxy) srcMgr.getCacheData(blitProxyKey);
	225	if (sdp == null \|\| !sdp.isValid()) {
	226	if (srcData.getState() == State.UNTRACKABLE) {
	227	sdp = SurfaceDataProxy.UNCACHED;
	228	} else {
	229	sdp = makeProxyFor(srcData);
	230	}
	231	srcMgr.setCacheData(blitProxyKey, sdp);
	232	}
	233	srcData = sdp.replaceData(srcData, txtype, comp, bgColor);
	234	}
	235	return srcData;
	236	}
	237
	238	/**
	239	* This method is called on a destination SurfaceData to choose
	240	* a proper SurfaceDataProxy subclass for a source SurfaceData
	241	* to use to control when and with what surface to override a
	242	* given image operation. The argument is the default SurfaceData
	243	* for the source Image.
	244	* <p>
	245	* The type of the return object is chosen based on the
	246	* acceleration capabilities of this SurfaceData and the
	247	* type of the given source SurfaceData object.
	248	* <p>
	249	* In some cases the original SurfaceData will always be the
	250	* best choice to use to blit to this SurfaceData. This can
	251	* happen if the source image is a hardware surface of the
	252	* same type as this one and so acceleration will happen without
	253	* any caching. It may also be the case that the source image
	254	* can never be accelerated on this SurfaceData - for example
	255	* because it is translucent and there are no accelerated
	256	* translucent image ops for this surface.
	257	* <p>
	258	* In those cases there is a special SurfaceDataProxy.UNCACHED
	259	* instance that represents a NOP for caching purposes - it
	260	* always returns the original sourceSD object as the replacement
	261	* copy so no caching is ever performed.
	262	*/
	263	public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {
	264	return SurfaceDataProxy.UNCACHED;
	265	}
	266
	267	/**
	268	* Extracts the SurfaceManager from the given Image, and then
	269	* returns the SurfaceData object that would best be suited as the
	270	* destination surface in some rendering operation.
	271	*/
	272	public static SurfaceData getPrimarySurfaceData(Image img) {
	273	SurfaceManager sMgr = SurfaceManager.getManager(img);
	274	return sMgr.getPrimarySurfaceData();
	275	}
	276
	277	/**
	278	* Restores the contents of the given Image and then returns the new
	279	* SurfaceData object in use by the Image's SurfaceManager.
	280	*/
	281	public static SurfaceData restoreContents(Image img) {
	282	SurfaceManager sMgr = SurfaceManager.getManager(img);
	283	return sMgr.restoreContents();
	284	}
	285
	286	public State getState() {
	287	return stateDelegate.getState();
	288	}
	289
	290	public StateTracker getStateTracker() {
	291	return stateDelegate.getStateTracker();
	292	}
	293
	294	/**
	295	* Marks this surface as dirty.
	296	*/
	297	public final void markDirty() {
	298	stateDelegate.markDirty();
	299	}
	300
	301	/**
	302	* Sets the value of the surfaceLost variable, which indicates whether
	303	* something has happened to the rendering surface such that it needs
	304	* to be restored and re-rendered.
	305	*/
	306	public void setSurfaceLost(boolean lost) {
	307	surfaceLost = lost;
	308	stateDelegate.markDirty();
	309	}
	310
	311	public boolean isSurfaceLost() {
	312	return surfaceLost;
	313	}
	314
	315	/**
	316	* Returns a boolean indicating whether or not this SurfaceData is valid.
	317	*/
	318	public final boolean isValid() {
	319	return valid;
	320	}
	321
	322	public Object getDisposerReferent() {
	323	return disposerReferent;
	324	}
	325
	326	public long getNativeOps() {
	327	return pData;
	328	}
	329
	330	/**
	331	* Sets this SurfaceData object to the invalid state. All Graphics
	332	* objects must get a new SurfaceData object via the refresh method
	333	* and revalidate their pipelines before continuing.
	334	*/
	335	public void invalidate() {
	336	valid = false;
	337	stateDelegate.markDirty();
	338	}
	339
	340	/**
	341	* Certain changes in the configuration of a surface require the
	342	* invalidation of existing associated SurfaceData objects and
	343	* the creation of brand new ones. These changes include size,
	344	* ColorModel, or SurfaceType. Existing Graphics objects
	345	* which are directed at such surfaces, however, must continue
	346	* to render to them even after the change occurs underneath
	347	* the covers. The getReplacement() method is called from
	348	* SunGraphics2D.revalidateAll() when the associated SurfaceData
	349	* is found to be invalid so that a Graphics object can continue
	350	* to render to the surface in its new configuration.
	351	*
	352	* Such changes only tend to happen to window based surfaces since
	353	* most image based surfaces never change size or pixel format.
	354	* Even VolatileImage objects never change size and they only
	355	* change their pixel format when manually validated against a
	356	* new GraphicsConfiguration, at which point old Graphics objects
	357	* are no longer expected to render to them after the validation
	358	* step. Thus, only window based surfaces really need to deal
	359	* with this form of replacement.
	360	*/
	361	public abstract SurfaceData getReplacement();
	362
	363	protected static final LoopPipe colorPrimitives;
	364
	365	public static final TextPipe outlineTextRenderer;
	366	public static final TextPipe solidTextRenderer;
	367	public static final TextPipe aaTextRenderer;
	368	public static final TextPipe lcdTextRenderer;
	369
	370	protected static final AlphaColorPipe colorPipe;
	371	protected static final PixelToShapeConverter colorViaShape;
	372	protected static final PixelToParallelogramConverter colorViaPgram;
	373	protected static final TextPipe colorText;
	374	protected static final CompositePipe clipColorPipe;
	375	protected static final TextPipe clipColorText;
	376	protected static final AAShapePipe AAColorShape;
	377	protected static final PixelToParallelogramConverter AAColorViaShape;
	378	protected static final PixelToParallelogramConverter AAColorViaPgram;
	379	protected static final AAShapePipe AAClipColorShape;
	380	protected static final PixelToParallelogramConverter AAClipColorViaShape;
	381
	382	protected static final CompositePipe paintPipe;
	383	protected static final SpanShapeRenderer paintShape;
	384	protected static final PixelToShapeConverter paintViaShape;
	385	protected static final TextPipe paintText;
	386	protected static final CompositePipe clipPaintPipe;
	387	protected static final TextPipe clipPaintText;
	388	protected static final AAShapePipe AAPaintShape;
	389	protected static final PixelToParallelogramConverter AAPaintViaShape;
	390	protected static final AAShapePipe AAClipPaintShape;
	391	protected static final PixelToParallelogramConverter AAClipPaintViaShape;
	392
	393	protected static final CompositePipe compPipe;
	394	protected static final SpanShapeRenderer compShape;
	395	protected static final PixelToShapeConverter compViaShape;
	396	protected static final TextPipe compText;
	397	protected static final CompositePipe clipCompPipe;
	398	protected static final TextPipe clipCompText;
	399	protected static final AAShapePipe AACompShape;
	400	protected static final PixelToParallelogramConverter AACompViaShape;
	401	protected static final AAShapePipe AAClipCompShape;
	402	protected static final PixelToParallelogramConverter AAClipCompViaShape;
	403
	404	protected static final DrawImagePipe imagepipe;
	405
	406	// Utility subclass to add the LoopBasedPipe tagging interface
	407	static class PixelToShapeLoopConverter
	408	extends PixelToShapeConverter
	409	implements LoopBasedPipe
	410	{
	411	public PixelToShapeLoopConverter(ShapeDrawPipe pipe) {
	412	super(pipe);
	413	}
	414	}
	415
	416	// Utility subclass to add the LoopBasedPipe tagging interface
	417	static class PixelToPgramLoopConverter
	418	extends PixelToParallelogramConverter
	419	implements LoopBasedPipe
	420	{
	421	public PixelToPgramLoopConverter(ShapeDrawPipe shapepipe,
	422	ParallelogramPipe pgrampipe,
	423	double minPenSize,
	424	double normPosition,
	425	boolean adjustfill)
	426	{
	427	super(shapepipe, pgrampipe, minPenSize, normPosition, adjustfill);
	428	}
	429	}
	430
	431	private static PixelToParallelogramConverter
	432	makeConverter(AAShapePipe renderer,
	433	ParallelogramPipe pgrampipe)
	434	{
	435	return new PixelToParallelogramConverter(renderer,
	436	pgrampipe,
	437	1.0/8.0, 0.499,
	438	false);
	439	}
	440
	441	private static PixelToParallelogramConverter
	442	makeConverter(AAShapePipe renderer)
	443	{
	444	return makeConverter(renderer, renderer);
	445	}
	446
	447	static {
	448	colorPrimitives = new LoopPipe();
	449
	450	outlineTextRenderer = new OutlineTextRenderer();
	451	solidTextRenderer = new SolidTextRenderer();
	452	aaTextRenderer = new AATextRenderer();
	453	lcdTextRenderer = new LCDTextRenderer();
	454
	455	colorPipe = new AlphaColorPipe();
	456	// colorShape = colorPrimitives;
	457	colorViaShape = new PixelToShapeLoopConverter(colorPrimitives);
	458	colorViaPgram = new PixelToPgramLoopConverter(colorPrimitives,
	459	colorPrimitives,
	460	1.0, 0.25, true);
	461	colorText = new TextRenderer(colorPipe);
	462	clipColorPipe = new SpanClipRenderer(colorPipe);
	463	clipColorText = new TextRenderer(clipColorPipe);
	464	AAColorShape = new AAShapePipe(colorPipe);
	465	AAColorViaShape = makeConverter(AAColorShape);
	466	AAColorViaPgram = makeConverter(AAColorShape, colorPipe);
	467	AAClipColorShape = new AAShapePipe(clipColorPipe);
	468	AAClipColorViaShape = makeConverter(AAClipColorShape);
	469
	470	paintPipe = new AlphaPaintPipe();
	471	paintShape = new SpanShapeRenderer.Composite(paintPipe);
	472	paintViaShape = new PixelToShapeConverter(paintShape);
	473	paintText = new TextRenderer(paintPipe);
	474	clipPaintPipe = new SpanClipRenderer(paintPipe);
	475	clipPaintText = new TextRenderer(clipPaintPipe);
	476	AAPaintShape = new AAShapePipe(paintPipe);
	477	AAPaintViaShape = makeConverter(AAPaintShape);
	478	AAClipPaintShape = new AAShapePipe(clipPaintPipe);
	479	AAClipPaintViaShape = makeConverter(AAClipPaintShape);
	480
	481	compPipe = new GeneralCompositePipe();
	482	compShape = new SpanShapeRenderer.Composite(compPipe);
	483	compViaShape = new PixelToShapeConverter(compShape);
	484	compText = new TextRenderer(compPipe);
	485	clipCompPipe = new SpanClipRenderer(compPipe);
	486	clipCompText = new TextRenderer(clipCompPipe);
	487	AACompShape = new AAShapePipe(compPipe);
	488	AACompViaShape = makeConverter(AACompShape);
	489	AAClipCompShape = new AAShapePipe(clipCompPipe);
	490	AAClipCompViaShape = makeConverter(AAClipCompShape);
	491
	492	imagepipe = new DrawImage();
	493	}
	494
	495	/* Not all surfaces and rendering mode combinations support LCD text. */
	496	static final int LOOP_UNKNOWN = 0;
	497	static final int LOOP_FOUND = 1;
	498	static final int LOOP_NOTFOUND = 2;
	499	int haveLCDLoop;
	500	int havePgramXORLoop;
	501	int havePgramSolidLoop;
	502
	503	public boolean canRenderLCDText(SunGraphics2D sg2d) {
	504	// For now the answer can only be true in the following cases:
	505	if (sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY &&
	506	sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
	507	sg2d.clipState <= SunGraphics2D.CLIP_RECTANGULAR &&
	508	sg2d.surfaceData.getTransparency() == Transparency.OPAQUE)
	509	{
	510	if (haveLCDLoop == LOOP_UNKNOWN) {
	511	DrawGlyphListLCD loop =
	512	DrawGlyphListLCD.locate(SurfaceType.AnyColor,
	513	CompositeType.SrcNoEa,
	514	getSurfaceType());
	515	haveLCDLoop = (loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
	516	}
	517	return haveLCDLoop == LOOP_FOUND;
	518	}
	519	return false; /* for now - in the future we may want to search */
	520	}
	521
	522	public boolean canRenderParallelograms(SunGraphics2D sg2d) {
	523	if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) {
	524	if (sg2d.compositeState == sg2d.COMP_XOR) {
	525	if (havePgramXORLoop == LOOP_UNKNOWN) {
	526	FillParallelogram loop =
	527	FillParallelogram.locate(SurfaceType.AnyColor,
	528	CompositeType.Xor,
	529	getSurfaceType());
	530	havePgramXORLoop =
	531	(loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
	532	}
	533	return havePgramXORLoop == LOOP_FOUND;
	534	} else if (sg2d.compositeState <= sg2d.COMP_ISCOPY &&
	535	sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
	536	sg2d.clipState != sg2d.CLIP_SHAPE)
	537	{
	538	if (havePgramSolidLoop == LOOP_UNKNOWN) {
	539	FillParallelogram loop =
	540	FillParallelogram.locate(SurfaceType.AnyColor,
	541	CompositeType.SrcNoEa,
	542	getSurfaceType());
	543	havePgramSolidLoop =
	544	(loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
	545	}
	546	return havePgramSolidLoop == LOOP_FOUND;
	547	}
	548	}
	549	return false;
	550	}
	551
	552	public void validatePipe(SunGraphics2D sg2d) {
	553	sg2d.imagepipe = imagepipe;
	554	if (sg2d.compositeState == sg2d.COMP_XOR) {
	555	if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
	556	sg2d.drawpipe = paintViaShape;
	557	sg2d.fillpipe = paintViaShape;
	558	sg2d.shapepipe = paintShape;
	559	// REMIND: Ideally custom paint mode would use glyph
	560	// rendering as opposed to outline rendering but the
	561	// glyph paint rendering pipeline uses MaskBlit which
	562	// is not defined for XOR. This means that text drawn
	563	// in XOR mode with a Color object is different than
	564	// text drawn in XOR mode with a Paint object.
	565	sg2d.textpipe = outlineTextRenderer;
	566	} else {
	567	PixelToShapeConverter converter;
	568	if (canRenderParallelograms(sg2d)) {
	569	converter = colorViaPgram;
	570	// Note that we use the transforming pipe here because it
	571	// will examine the shape and possibly perform an optimized
	572	// operation if it can be simplified. The simplifications
	573	// will be valid for all STROKE and TRANSFORM types.
	574	sg2d.shapepipe = colorViaPgram;
	575	} else {
	576	converter = colorViaShape;
	577	sg2d.shapepipe = colorPrimitives;
	578	}
	579	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	580	sg2d.drawpipe = converter;
	581	sg2d.fillpipe = converter;
	582	// REMIND: We should not be changing text strategies
	583	// between outline and glyph rendering based upon the
	584	// presence of a complex clip as that could cause a
	585	// mismatch when drawing the same text both clipped
	586	// and unclipped on two separate rendering passes.
	587	// Unfortunately, all of the clipped glyph rendering
	588	// pipelines rely on the use of the MaskBlit operation
	589	// which is not defined for XOR.
	590	sg2d.textpipe = outlineTextRenderer;
	591	} else {
	592	if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
	593	sg2d.drawpipe = converter;
	594	sg2d.fillpipe = converter;
	595	} else {
	596	if (sg2d.strokeState != sg2d.STROKE_THIN) {
	597	sg2d.drawpipe = converter;
	598	} else {
	599	sg2d.drawpipe = colorPrimitives;
	600	}
	601	sg2d.fillpipe = colorPrimitives;
	602	}
	603	sg2d.textpipe = solidTextRenderer;
	604	}
	605	// assert(sg2d.surfaceData == this);
	606	}
	607	} else if (sg2d.compositeState == sg2d.COMP_CUSTOM) {
	608	if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
	609	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	610	sg2d.drawpipe = AAClipCompViaShape;
	611	sg2d.fillpipe = AAClipCompViaShape;
	612	sg2d.shapepipe = AAClipCompViaShape;
	613	sg2d.textpipe = clipCompText;
	614	} else {
	615	sg2d.drawpipe = AACompViaShape;
	616	sg2d.fillpipe = AACompViaShape;
	617	sg2d.shapepipe = AACompViaShape;
	618	sg2d.textpipe = compText;
	619	}
	620	} else {
	621	sg2d.drawpipe = compViaShape;
	622	sg2d.fillpipe = compViaShape;
	623	sg2d.shapepipe = compShape;
	624	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	625	sg2d.textpipe = clipCompText;
	626	} else {
	627	sg2d.textpipe = compText;
	628	}
	629	}
	630	} else if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
	631	sg2d.alphafill = getMaskFill(sg2d);
	632	// assert(sg2d.surfaceData == this);
	633	if (sg2d.alphafill != null) {
	634	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	635	sg2d.drawpipe = AAClipColorViaShape;
	636	sg2d.fillpipe = AAClipColorViaShape;
	637	sg2d.shapepipe = AAClipColorViaShape;
	638	sg2d.textpipe = clipColorText;
	639	} else {
	640	PixelToParallelogramConverter converter =
	641	(sg2d.alphafill.canDoParallelograms()
	642	? AAColorViaPgram
	643	: AAColorViaShape);
	644	sg2d.drawpipe = converter;
	645	sg2d.fillpipe = converter;
	646	sg2d.shapepipe = converter;
	647	if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR \|\|
	648	sg2d.compositeState > sg2d.COMP_ISCOPY)
	649	{
	650	sg2d.textpipe = colorText;
	651	} else {
	652	sg2d.textpipe = getTextPipe(sg2d, true /* AA==ON */);
	653	}
	654	}
	655	} else {
	656	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	657	sg2d.drawpipe = AAClipPaintViaShape;
	658	sg2d.fillpipe = AAClipPaintViaShape;
	659	sg2d.shapepipe = AAClipPaintViaShape;
	660	sg2d.textpipe = clipPaintText;
	661	} else {
	662	sg2d.drawpipe = AAPaintViaShape;
	663	sg2d.fillpipe = AAPaintViaShape;
	664	sg2d.shapepipe = AAPaintViaShape;
	665	sg2d.textpipe = paintText;
	666	}
	667	}
	668	} else if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR \|\|
	669	sg2d.compositeState > sg2d.COMP_ISCOPY \|\|
	670	sg2d.clipState == sg2d.CLIP_SHAPE)
	671	{
	672	sg2d.drawpipe = paintViaShape;
	673	sg2d.fillpipe = paintViaShape;
	674	sg2d.shapepipe = paintShape;
	675	sg2d.alphafill = getMaskFill(sg2d);
	676	// assert(sg2d.surfaceData == this);
	677	if (sg2d.alphafill != null) {
	678	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	679	sg2d.textpipe = clipColorText;
	680	} else {
	681	sg2d.textpipe = colorText;
	682	}
	683	} else {
	684	if (sg2d.clipState == sg2d.CLIP_SHAPE) {
	685	sg2d.textpipe = clipPaintText;
	686	} else {
	687	sg2d.textpipe = paintText;
	688	}
	689	}
	690	} else {
	691	PixelToShapeConverter converter;
	692	if (canRenderParallelograms(sg2d)) {
	693	converter = colorViaPgram;
	694	// Note that we use the transforming pipe here because it
	695	// will examine the shape and possibly perform an optimized
	696	// operation if it can be simplified. The simplifications
	697	// will be valid for all STROKE and TRANSFORM types.
	698	sg2d.shapepipe = colorViaPgram;
	699	} else {
	700	converter = colorViaShape;
	701	sg2d.shapepipe = colorPrimitives;
	702	}
	703	if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
	704	sg2d.drawpipe = converter;
	705	sg2d.fillpipe = converter;
	706	} else {
	707	if (sg2d.strokeState != sg2d.STROKE_THIN) {
	708	sg2d.drawpipe = converter;
	709	} else {
	710	sg2d.drawpipe = colorPrimitives;
	711	}
	712	sg2d.fillpipe = colorPrimitives;
	713	}
	714
	715	sg2d.textpipe = getTextPipe(sg2d, false /* AA==OFF */);
	716	// assert(sg2d.surfaceData == this);
	717	}
	718
	719	// check for loops
	720	if (sg2d.textpipe instanceof LoopBasedPipe \|\|
	721	sg2d.shapepipe instanceof LoopBasedPipe \|\|
	722	sg2d.fillpipe instanceof LoopBasedPipe \|\|
	723	sg2d.drawpipe instanceof LoopBasedPipe \|\|
	724	sg2d.imagepipe instanceof LoopBasedPipe)
	725	{
	726	sg2d.loops = getRenderLoops(sg2d);
	727	}
	728	}
	729
	730	/* Return the text pipe to be used based on the graphics AA hint setting,
	731	* and the rest of the graphics state is compatible with these loops.
	732	* If the text AA hint is "DEFAULT", then the AA graphics hint requests
	733	* the AA text renderer, else it requests the B&W text renderer.
	734	*/
	735	private TextPipe getTextPipe(SunGraphics2D sg2d, boolean aaHintIsOn) {
	736
	737	/* Try to avoid calling getFontInfo() unless its needed to
	738	* resolve one of the new AA types.
	739	*/
	740	switch (sg2d.textAntialiasHint) {
	741	case SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT:
	742	if (aaHintIsOn) {
	743	return aaTextRenderer;
	744	} else {
	745	return solidTextRenderer;
	746	}
	747	case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
	748	return solidTextRenderer;
	749
	750	case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
	751	return aaTextRenderer;
	752
	753	default:
	754	switch (sg2d.getFontInfo().aaHint) {
	755
	756	case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:
	757	case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:
	758	return lcdTextRenderer;
	759
	760	case SunHints.INTVAL_TEXT_ANTIALIAS_ON:
	761	return aaTextRenderer;
	762
	763	case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
	764	return solidTextRenderer;
	765
	766	/* This should not be reached as the FontInfo will
	767	* always explicitly set its hint value. So whilst
	768	* this could be collapsed to returning say just
	769	* solidTextRenderer, or even removed, its left
	770	* here in case DEFAULT is ever passed in.
	771	*/
	772	default:
	773	if (aaHintIsOn) {
	774	return aaTextRenderer;
	775	} else {
	776	return solidTextRenderer;
	777	}
	778	}
	779	}
	780	}
	781
	782	private static SurfaceType getPaintSurfaceType(SunGraphics2D sg2d) {
	783	switch (sg2d.paintState) {
	784	case SunGraphics2D.PAINT_OPAQUECOLOR:
	785	return SurfaceType.OpaqueColor;
	786	case SunGraphics2D.PAINT_ALPHACOLOR:
	787	return SurfaceType.AnyColor;
	788	case SunGraphics2D.PAINT_GRADIENT:
	789	if (sg2d.paint.getTransparency() == OPAQUE) {
	790	return SurfaceType.OpaqueGradientPaint;
	791	} else {
	792	return SurfaceType.GradientPaint;
	793	}
	794	case SunGraphics2D.PAINT_LIN_GRADIENT:
	795	if (sg2d.paint.getTransparency() == OPAQUE) {
	796	return SurfaceType.OpaqueLinearGradientPaint;
	797	} else {
	798	return SurfaceType.LinearGradientPaint;
	799	}
	800	case SunGraphics2D.PAINT_RAD_GRADIENT:
	801	if (sg2d.paint.getTransparency() == OPAQUE) {
	802	return SurfaceType.OpaqueRadialGradientPaint;
	803	} else {
	804	return SurfaceType.RadialGradientPaint;
	805	}
	806	case SunGraphics2D.PAINT_TEXTURE:
	807	if (sg2d.paint.getTransparency() == OPAQUE) {
	808	return SurfaceType.OpaqueTexturePaint;
	809	} else {
	810	return SurfaceType.TexturePaint;
	811	}
	812	default:
	813	case SunGraphics2D.PAINT_CUSTOM:
	814	return SurfaceType.AnyPaint;
	815	}
	816	}
	817
	818	private static CompositeType getFillCompositeType(SunGraphics2D sg2d) {
	819	CompositeType compType = sg2d.imageComp;
	820	if (sg2d.compositeState == sg2d.COMP_ISCOPY) {
	821	if (compType == CompositeType.SrcOverNoEa) {
	822	compType = CompositeType.OpaqueSrcOverNoEa;
	823	} else {
	824	compType = CompositeType.SrcNoEa;
	825	}
	826	}
	827	return compType;
	828	}
	829
	830	/**
	831	* Returns a MaskFill object that can be used on this destination
	832	* with the source (paint) and composite types determined by the given
	833	* SunGraphics2D, or null if no such MaskFill object can be located.
	834	* Subclasses can override this method if they wish to filter other
	835	* attributes (such as the hardware capabilities of the destination
	836	* surface) before returning a specific MaskFill object.
	837	*/
	838	protected MaskFill getMaskFill(SunGraphics2D sg2d) {
	839	SurfaceType src = getPaintSurfaceType(sg2d);
	840	CompositeType comp = getFillCompositeType(sg2d);
	841	SurfaceType dst = getSurfaceType();
	842	return MaskFill.getFromCache(src, comp, dst);
	843	}
	844
	845	private static RenderCache loopcache = new RenderCache(30);
	846
	847	/**
	848	* Return a RenderLoops object containing all of the basic
	849	* GraphicsPrimitive objects for rendering to the destination
	850	* surface with the current attributes of the given SunGraphics2D.
	851	*/
	852	public RenderLoops getRenderLoops(SunGraphics2D sg2d) {
	853	SurfaceType src = getPaintSurfaceType(sg2d);
	854	CompositeType comp = getFillCompositeType(sg2d);
	855	SurfaceType dst = sg2d.getSurfaceData().getSurfaceType();
	856
	857	Object o = loopcache.get(src, comp, dst);
	858	if (o != null) {
	859	return (RenderLoops) o;
	860	}
	861
	862	RenderLoops loops = makeRenderLoops(src, comp, dst);
	863	loopcache.put(src, comp, dst, loops);
	864	return loops;
	865	}
	866
	867	/**
	868	* Construct and return a RenderLoops object containing all of
	869	* the basic GraphicsPrimitive objects for rendering to the
	870	* destination surface with the given source, destination, and
	871	* composite types.
	872	*/
	873	public static RenderLoops makeRenderLoops(SurfaceType src,
	874	CompositeType comp,
	875	SurfaceType dst)
	876	{
	877	RenderLoops loops = new RenderLoops();
	878	loops.drawLineLoop = DrawLine.locate(src, comp, dst);
	879	loops.fillRectLoop = FillRect.locate(src, comp, dst);
	880	loops.drawRectLoop = DrawRect.locate(src, comp, dst);
	881	loops.drawPolygonsLoop = DrawPolygons.locate(src, comp, dst);
	882	loops.drawPathLoop = DrawPath.locate(src, comp, dst);
	883	loops.fillPathLoop = FillPath.locate(src, comp, dst);
	884	loops.fillSpansLoop = FillSpans.locate(src, comp, dst);
	885	loops.fillParallelogramLoop = FillParallelogram.locate(src, comp, dst);
	886	loops.drawParallelogramLoop = DrawParallelogram.locate(src, comp, dst);
	887	loops.drawGlyphListLoop = DrawGlyphList.locate(src, comp, dst);
	888	loops.drawGlyphListAALoop = DrawGlyphListAA.locate(src, comp, dst);
	889	loops.drawGlyphListLCDLoop = DrawGlyphListLCD.locate(src, comp, dst);
	890	/*
	891	System.out.println("drawLine: "+loops.drawLineLoop);
	892	System.out.println("fillRect: "+loops.fillRectLoop);
	893	System.out.println("drawRect: "+loops.drawRectLoop);
	894	System.out.println("drawPolygons: "+loops.drawPolygonsLoop);
	895	System.out.println("fillSpans: "+loops.fillSpansLoop);
	896	System.out.println("drawGlyphList: "+loops.drawGlyphListLoop);
	897	System.out.println("drawGlyphListAA: "+loops.drawGlyphListAALoop);
	898	System.out.println("drawGlyphListLCD: "+loops.drawGlyphListLCDLoop);
	899	*/
	900	return loops;
	901	}
	902
	903	/**
	904	* Return the GraphicsConfiguration object that describes this
	905	* destination surface.
	906	*/
	907	public abstract GraphicsConfiguration getDeviceConfiguration();
	908
	909	/**
	910	* Return the SurfaceType object that describes the destination
	911	* surface.
	912	*/
	913	public final SurfaceType getSurfaceType() {
	914	return surfaceType;
	915	}
	916
	917	/**
	918	* Return the ColorModel for the destination surface.
	919	*/
	920	public final ColorModel getColorModel() {
	921	return colorModel;
	922	}
	923
	924	/**
	925	* Returns the type of this <code>Transparency</code>.
	926	* @return the field type of this <code>Transparency</code>, which is
	927	* either OPAQUE, BITMASK or TRANSLUCENT.
	928	*/
	929	public int getTransparency() {
	930	return getColorModel().getTransparency();
	931	}
	932
	933	/**
	934	* Return a readable Raster which contains the pixels for the
	935	* specified rectangular region of the destination surface.
	936	* The coordinate origin of the returned Raster is the same as
	937	* the device space origin of the destination surface.
	938	* In some cases the returned Raster might also be writeable.
	939	* In most cases, the returned Raster might contain more pixels
	940	* than requested.
	941	*
	942	* @see useTightBBoxes
	943	*/
	944	public abstract Raster getRaster(int x, int y, int w, int h);
	945
	946	/**
	947	* Does the pixel accessibility of the destination surface
	948	* suggest that rendering algorithms might want to take
	949	* extra time to calculate a more accurate bounding box for
	950	* the operation being performed?
	951	* The typical case when this will be true is when a copy of
	952	* the pixels has to be made when doing a getRaster. The
	953	* fewer pixels copied, the faster the operation will go.
	954	*
	955	* @see getRaster
	956	*/
	957	public boolean useTightBBoxes() {
	958	// Note: The native equivalent would trigger on VISIBLE_TO_NATIVE
	959	// REMIND: This is not used - should be obsoleted maybe
	960	return true;
	961	}
	962
	963	/**
	964	* Returns the pixel data for the specified Argb value packed
	965	* into an integer for easy storage and conveyance.
	966	*/
	967	public int pixelFor(int rgb) {
	968	return surfaceType.pixelFor(rgb, colorModel);
	969	}
	970
	971	/**
	972	* Returns the pixel data for the specified color packed into an
	973	* integer for easy storage and conveyance.
	974	*
	975	* This method will use the getRGB() method of the Color object
	976	* and defer to the pixelFor(int rgb) method if not overridden.
	977	*
	978	* For now this is a convenience function, but for cases where
	979	* the highest quality color conversion is requested, this method
	980	* should be overridden in those cases so that a more direct
	981	* conversion of the color to the destination color space
	982	* can be done using the additional information in the Color
	983	* object.
	984	*/
	985	public int pixelFor(Color c) {
	986	return pixelFor(c.getRGB());
	987	}
	988
	989	/**
	990	* Returns the Argb representation for the specified integer value
	991	* which is packed in the format of the associated ColorModel.
	992	*/
	993	public int rgbFor(int pixel) {
	994	return surfaceType.rgbFor(pixel, colorModel);
	995	}
	996
	997	/**
	998	* Returns the bounds of the destination surface.
	999	*/
	1000	public abstract Rectangle getBounds();
	1001
	1002	static java.security.Permission compPermission;
	1003
	1004	/**
	1005	* Performs Security Permissions checks to see if a Custom
	1006	* Composite object should be allowed access to the pixels
	1007	* of this surface.
	1008	*/
	1009	protected void checkCustomComposite() {
	1010	SecurityManager sm = System.getSecurityManager();
	1011	if (sm != null) {
	1012	if (compPermission == null) {
	1013	compPermission =
	1014	new java.awt.AWTPermission("readDisplayPixels");
	1015	}
	1016	sm.checkPermission(compPermission);
	1017	}
	1018	}
	1019
	1020	/**
	1021	* Fetches private field IndexColorModel.allgrayopaque
	1022	* which is true when all palette entries in the color
	1023	* model are gray and opaque.
	1024	*/
	1025	protected static native boolean isOpaqueGray(IndexColorModel icm);
	1026
	1027	/**
	1028	* For our purposes null and NullSurfaceData are the same as
	1029	* they represent a disposed surface.
	1030	*/
	1031	public static boolean isNull(SurfaceData sd) {
	1032	if (sd == null \|\| sd == NullSurfaceData.theInstance) {
	1033	return true;
	1034	}
	1035	return false;
	1036	}
	1037
	1038	/**
	1039	* Performs a copyarea within this surface. Returns
	1040	* false if there is no algorithm to perform the copyarea
	1041	* given the current settings of the SunGraphics2D.
	1042	*/
	1043	public boolean copyArea(SunGraphics2D sg2d,
	1044	int x, int y, int w, int h, int dx, int dy)
	1045	{
	1046	return false;
	1047	}
	1048
	1049	/**
	1050	* Synchronously releases resources associated with this surface.
	1051	*/
	1052	public void flush() {}
	1053
	1054	/**
	1055	* Returns destination associated with this SurfaceData. This could be
	1056	* either an Image or a Component; subclasses of SurfaceData are
	1057	* responsible for returning the appropriate object.
	1058	*/
	1059	public abstract Object getDestination();
	1060	}

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

Binary file not shown.

java/pkg/sun/java2d/SurfaceDataProxy$CountdownTracker.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SurfaceDataProxy.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SurfaceDataProxy.java+528−0

@@ -0,0 +1,528 @@
	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;
	27
	28	import java.awt.Color;
	29	import java.awt.Rectangle;
	30	import java.awt.AlphaComposite;
	31	import java.awt.GraphicsEnvironment;
	32
	33	import sun.awt.DisplayChangedListener;
	34	import sun.java2d.StateTrackable.State;
	35	import sun.java2d.loops.CompositeType;
	36	import sun.java2d.loops.SurfaceType;
	37	import sun.java2d.loops.Blit;
	38	import sun.java2d.loops.BlitBg;
	39	import sun.awt.image.SurfaceManager;
	40	import sun.awt.image.SurfaceManager.FlushableCacheData;
	41
	42	import java.security.AccessController;
	43	import sun.security.action.GetPropertyAction;
	44
	45	/**
	46	* The proxy class encapsulates the logic for managing alternate
	47	* SurfaceData representations of a primary SurfaceData.
	48	* The main class will handle tracking the state changes of the
	49	* primary SurfaceData and updating the associated SurfaceData
	50	* proxy variants.
	51	* <p>
	52	* Subclasses have 2 main responsibilities:
	53	* <ul>
	54	* <li> Override the isSupportedOperation() method to determine if
	55	* a given operation can be accelerated with a given source
	56	* SurfaceData
	57	* <li> Override the validateSurfaceData() method to create or update
	58	* a given accelerated surface to hold the pixels for the indicated
	59	* source SurfaceData
	60	* </ul>
	61	* If necessary, a subclass may also override the updateSurfaceData
	62	* method to transfer the pixels to the accelerated surface.
	63	* By default the parent class will transfer the pixels using a
	64	* standard Blit operation between the two SurfaceData objects.
	65	*/
	66	public abstract class SurfaceDataProxy
	67	implements DisplayChangedListener, SurfaceManager.FlushableCacheData
	68	{
	69	private static boolean cachingAllowed;
	70	private static int defaultThreshold;
	71
	72	static {
	73	cachingAllowed = true;
	74	String manimg = (String)AccessController.doPrivileged(
	75	new GetPropertyAction("sun.java2d.managedimages"));
	76	if (manimg != null && manimg.equals("false")) {
	77	cachingAllowed = false;
	78	System.out.println("Disabling managed images");
	79	}
	80
	81	defaultThreshold = 1;
	82	String num = (String)AccessController.doPrivileged(
	83	new GetPropertyAction("sun.java2d.accthreshold"));
	84	if (num != null) {
	85	try {
	86	int parsed = Integer.parseInt(num);
	87	if (parsed >= 0) {
	88	defaultThreshold = parsed;
	89	System.out.println("New Default Acceleration Threshold: " +
	90	defaultThreshold);
	91	}
	92	} catch (NumberFormatException e) {
	93	System.err.println("Error setting new threshold:" + e);
	94	}
	95	}
	96	}
	97
	98	public static boolean isCachingAllowed() {
	99	return cachingAllowed;
	100	}
	101
	102	/**
	103	* Determine if an alternate form for the srcData is needed
	104	* and appropriate from the given operational parameters.
	105	*/
	106	public abstract boolean isSupportedOperation(SurfaceData srcData,
	107	int txtype,
	108	CompositeType comp,
	109	Color bgColor);
	110
	111	/**
	112	* Construct an alternate form of the given SurfaceData.
	113	* The contents of the returned SurfaceData may be undefined
	114	* since the calling code will take care of updating the
	115	* contents with a subsequent call to updateSurfaceData.
	116	* <p>
	117	* If the method returns null then there was a problem with
	118	* allocating the accelerated surface. The getRetryTracker()
	119	* method will be called to track when to attempt another
	120	* revalidation.
	121	*/
	122	public abstract SurfaceData validateSurfaceData(SurfaceData srcData,
	123	SurfaceData cachedData,
	124	int w, int h);
	125
	126	/**
	127	* If the subclass is unable to validate or create a cached
	128	* SurfaceData then this method will be used to get a
	129	* StateTracker object that will indicate when to attempt
	130	* to validate the surface again. Subclasses may return
	131	* trackers which count down an ever increasing threshold
	132	* to provide hysteresis on creating surfaces during low
	133	* memory conditions. The default implementation just waits
	134	* another "threshold" number of accesses before trying again.
	135	*/
	136	public StateTracker getRetryTracker(SurfaceData srcData) {
	137	return new CountdownTracker(threshold);
	138	}
	139
	140	public static class CountdownTracker implements StateTracker {
	141	private int countdown;
	142
	143	public CountdownTracker(int threshold) {
	144	this.countdown = threshold;
	145	}
	146
	147	public synchronized boolean isCurrent() {
	148	return (--countdown >= 0);
	149	}
	150	}
	151
	152	/**
	153	* This instance is for cases where a caching implementation
	154	* determines that a particular source image will never need
	155	* to be cached - either the source SurfaceData was of an
	156	* incompatible type, or it was in an UNTRACKABLE state or
	157	* some other factor is discovered that permanently prevents
	158	* acceleration or caching.
	159	* This class optimally implements NOP variants of all necessary
	160	* methods to avoid caching with a minimum of fuss.
	161	*/
	162	public static SurfaceDataProxy UNCACHED = new SurfaceDataProxy(0) {
	163	@Override
	164	public boolean isAccelerated() {
	165	return false;
	166	}
	167
	168	@Override
	169	public boolean isSupportedOperation(SurfaceData srcData,
	170	int txtype,
	171	CompositeType comp,
	172	Color bgColor)
	173	{
	174	return false;
	175	}
	176
	177	@Override
	178	public SurfaceData validateSurfaceData(SurfaceData srcData,
	179	SurfaceData cachedData,
	180	int w, int h)
	181	{
	182	throw new InternalError("UNCACHED should never validate SDs");
	183	}
	184
	185	@Override
	186	public SurfaceData replaceData(SurfaceData srcData,
	187	int txtype,
	188	CompositeType comp,
	189	Color bgColor)
	190	{
	191	// Not necessary to override this, but doing so is faster
	192	return srcData;
	193	}
	194	};
	195
	196	// The number of attempts to copy from a STABLE source before
	197	// a cached copy is created or updated.
	198	private int threshold;
	199
	200	/*
	201	* Source tracking data
	202	*
	203	* Every time that srcTracker is out of date we will reset numtries
	204	* to threshold and set the cacheTracker to one that is non-current.
	205	* numtries will then count down to 0 at which point the cacheTracker
	206	* will remind us that we need to update the cachedSD before we can
	207	* use it.
	208	*
	209	* Note that since these fields interrelate we should synchronize
	210	* whenever we update them, but it should be OK to read them
	211	* without synchronization.
	212	*/
	213	private StateTracker srcTracker;
	214	private int numtries;
	215
	216	/*
	217	* Cached data
	218	*
	219	* We cache a SurfaceData created by the subclass in cachedSD and
	220	* track its state (isValid and !surfaceLost) in cacheTracker.
	221	*
	222	* Also, when we want to note that cachedSD needs to be updated
	223	* we replace the cacheTracker with a NEVER_CURRENT tracker which
	224	* will cause us to try to revalidate and update the surface on
	225	* next use.
	226	*/
	227	private SurfaceData cachedSD;
	228	private StateTracker cacheTracker;
	229
	230	/*
	231	* Are we still the best object to control caching of data
	232	* for the source image?
	233	*/
	234	private boolean valid;
	235
	236	/**
	237	* Create a SurfaceData proxy manager that attempts to create
	238	* and cache a variant copy of the source SurfaceData after
	239	* the default threshold number of attempts to copy from the
	240	* STABLE source.
	241	*/
	242	public SurfaceDataProxy() {
	243	this(defaultThreshold);
	244	}
	245
	246	/**
	247	* Create a SurfaceData proxy manager that attempts to create
	248	* and cache a variant copy of the source SurfaceData after
	249	* the specified threshold number of attempts to copy from
	250	* the STABLE source.
	251	*/
	252	public SurfaceDataProxy(int threshold) {
	253	this.threshold = threshold;
	254
	255	this.srcTracker = StateTracker.NEVER_CURRENT;
	256	// numtries will be reset on first use
	257	this.cacheTracker = StateTracker.NEVER_CURRENT;
	258
	259	this.valid = true;
	260	}
	261
	262	/**
	263	* Returns true iff this SurfaceData proxy is still the best
	264	* way to control caching of the given source on the given
	265	* destination.
	266	*/
	267	public boolean isValid() {
	268	return valid;
	269	}
	270
	271	/**
	272	* Sets the valid state to false so that the next time this
	273	* proxy is fetched to generate a replacement SurfaceData,
	274	* the code in SurfaceData knows to replace the proxy first.
	275	*/
	276	public void invalidate() {
	277	this.valid = false;
	278	}
	279
	280	/**
	281	* Flush all cached resources as per the FlushableCacheData interface.
	282	* The deaccelerated parameter indicates if the flush is
	283	* happening because the associated surface is no longer
	284	* being accelerated (for instance the acceleration priority
	285	* is set below the threshold needed for acceleration).
	286	* Returns a boolean that indicates if the cached object is
	287	* no longer needed and should be removed from the cache.
	288	*/
	289	public boolean flush(boolean deaccelerated) {
	290	if (deaccelerated) {
	291	invalidate();
	292	}
	293	flush();
	294	return !isValid();
	295	}
	296
	297	/**
	298	* Actively flushes (drops and invalidates) the cached surface
	299	* so that it can be reclaimed quickly.
	300	*/
	301	public synchronized void flush() {
	302	SurfaceData csd = this.cachedSD;
	303	this.cachedSD = null;
	304	this.cacheTracker = StateTracker.NEVER_CURRENT;
	305	if (csd != null) {
	306	csd.flush();
	307	}
	308	}
	309
	310	/**
	311	* Returns true iff this SurfaceData proxy is still valid
	312	* and if it has a currently cached replacement that is also
	313	* valid and current.
	314	*/
	315	public boolean isAccelerated() {
	316	return (isValid() &&
	317	srcTracker.isCurrent() &&
	318	cacheTracker.isCurrent());
	319	}
	320
	321	/**
	322	* This method should be called from subclasses which create
	323	* cached SurfaceData objects that depend on the current
	324	* properties of the display.
	325	*/
	326	protected void activateDisplayListener() {
	327	GraphicsEnvironment ge =
	328	GraphicsEnvironment.getLocalGraphicsEnvironment();
	329	// We could have a HeadlessGE at this point, so double-check before
	330	// assuming anything.
	331	// Also, no point in listening to display change events if
	332	// the image is never going to be accelerated.
	333	if (ge instanceof SunGraphicsEnvironment) {
	334	((SunGraphicsEnvironment)ge).addDisplayChangedListener(this);
	335	}
	336	}
	337
	338	/**
	339	* Invoked when the display mode has changed.
	340	* This method will invalidate and drop the internal cachedSD object.
	341	*/
	342	public void displayChanged() {
	343	flush();
	344	}
	345
	346	/**
	347	* Invoked when the palette has changed.
	348	*/
	349	public void paletteChanged() {
	350	// We could potentially get away with just resetting cacheTracker
	351	// here but there is a small window of vulnerability in the
	352	// replaceData method where we could be just finished with
	353	// updating the cachedSD when this method is called and even
	354	// though we set a non-current cacheTracker here it will then
	355	// immediately get set to a current one by the thread that is
	356	// updating the cachedSD. It is safer to just replace the
	357	// srcTracker with a non-current version that will trigger a
	358	// full update cycle the next time this proxy is used.
	359	// The downside is having to go through a full threshold count
	360	// before we can update and use our cache again, but palette
	361	// changes should be relatively rare...
	362	this.srcTracker = StateTracker.NEVER_CURRENT;
	363	}
	364
	365	/**
	366	* This method attempts to replace the srcData with a cached version.
	367	* It relies on the subclass to determine if the cached version will
	368	* be useful given the operational parameters.
	369	* This method checks any preexisting cached copy for being "up to date"
	370	* and tries to update it if it is stale or non-existant and the
	371	* appropriate number of accesses have occured since it last was stale.
	372	* <p>
	373	* An outline of the process is as follows:
	374	* <ol>
	375	* <li> Check the operational parameters (txtype, comp, bgColor)
	376	* to make sure that the operation is supported. Return the
	377	* original SurfaceData if the operation cannot be accelerated.
	378	* <li> Check the tracker for the source surface to see if it has
	379	* remained stable since it was last cached. Update the state
	380	* variables to cause both a threshold countdown and an update
	381	* of the cached copy if it is not. (Setting cacheTracker to
	382	* NEVER_CURRENT effectively marks it as "needing to be updated".)
	383	* <li> Check the tracker for the cached copy to see if is still
	384	* valid and up to date. Note that the cacheTracker may be
	385	* non-current if either something happened to the cached copy
	386	* (eg. surfaceLost) or if the source was out of date and the
	387	* cacheTracker was set to NEVER_CURRENT to force an update.
	388	* Decrement the countdown and copy the source to the cache
	389	* as necessary and then update the variables to show that
	390	* the cached copy is stable.
	391	* </ol>
	392	*/
	393	public SurfaceData replaceData(SurfaceData srcData,
	394	int txtype,
	395	CompositeType comp,
	396	Color bgColor)
	397	{
	398	if (isSupportedOperation(srcData, txtype, comp, bgColor)) {
	399	// First deal with tracking the source.
	400	if (!srcTracker.isCurrent()) {
	401	synchronized (this) {
	402	this.numtries = threshold;
	403	this.srcTracker = srcData.getStateTracker();
	404	this.cacheTracker = StateTracker.NEVER_CURRENT;
	405	}
	406
	407	if (!srcTracker.isCurrent()) {
	408	// Dynamic or Untrackable (or a very recent modification)
	409	if (srcData.getState() == State.UNTRACKABLE) {
	410	// UNTRACKABLE means we can never cache again.
	411
	412	// Invalidate so we get replaced next time we are used
	413	// (presumably with an UNCACHED proxy).
	414	invalidate();
	415
	416	// Aggressively drop our reference to the cachedSD
	417	// in case this proxy is not consulted again (and
	418	// thus replaced) for a long time.
	419	flush();
	420	}
	421	return srcData;
	422	}
	423	}
	424
	425	// Then deal with checking the validity of the cached SurfaceData
	426	SurfaceData csd = this.cachedSD;
	427	if (!cacheTracker.isCurrent()) {
	428	// Next make sure the dust has settled
	429	synchronized (this) {
	430	if (numtries > 0) {
	431	--numtries;
	432	return srcData;
	433	}
	434	}
	435
	436	Rectangle r = srcData.getBounds();
	437	int w = r.width;
	438	int h = r.height;
	439
	440	// Snapshot the tracker in case it changes while
	441	// we are updating the cached SD...
	442	StateTracker curTracker = srcTracker;
	443
	444	csd = validateSurfaceData(srcData, csd, w, h);
	445	if (csd == null) {
	446	synchronized (this) {
	447	if (curTracker == srcTracker) {
	448	this.cacheTracker = getRetryTracker(srcData);
	449	this.cachedSD = null;
	450	}
	451	}
	452	return srcData;
	453	}
	454
	455	updateSurfaceData(srcData, csd, w, h);
	456	if (!csd.isValid()) {
	457	return srcData;
	458	}
	459
	460	synchronized (this) {
	461	// We only reset these variables if the tracker from
	462	// before the surface update is still in use and current
	463	// Note that we must use a srcTracker that was fetched
	464	// from before the update process to make sure that we
	465	// do not lose some pixel changes in the shuffle.
	466	if (curTracker == srcTracker && curTracker.isCurrent()) {
	467	this.cacheTracker = csd.getStateTracker();
	468	this.cachedSD = csd;
	469	}
	470	}
	471	}
	472
	473	if (csd != null) {
	474	return csd;
	475	}
	476	}
	477
	478	return srcData;
	479	}
	480
	481	/**
	482	* This is the default implementation for updating the cached
	483	* SurfaceData from the source (primary) SurfaceData.
	484	* A simple Blit is used to copy the pixels from the source to
	485	* the destination SurfaceData.
	486	* A subclass can override this implementation if a more complex
	487	* operation is required to update its cached copies.
	488	*/
	489	public void updateSurfaceData(SurfaceData srcData,
	490	SurfaceData dstData,
	491	int w, int h)
	492	{
	493	SurfaceType srcType = srcData.getSurfaceType();
	494	SurfaceType dstType = dstData.getSurfaceType();
	495	Blit blit = Blit.getFromCache(srcType,
	496	CompositeType.SrcNoEa,
	497	dstType);
	498	blit.Blit(srcData, dstData,
	499	AlphaComposite.Src, null,
	500	0, 0, 0, 0, w, h);
	501	dstData.markDirty();
	502	}
	503
	504	/**
	505	* This is an alternate implementation for updating the cached
	506	* SurfaceData from the source (primary) SurfaceData using a
	507	* background color for transparent pixels.
	508	* A simple BlitBg is used to copy the pixels from the source to
	509	* the destination SurfaceData with the specified bgColor.
	510	* A subclass can override the normal updateSurfaceData method
	511	* and call this implementation instead if it wants to use color
	512	* keying for bitmask images.
	513	*/
	514	public void updateSurfaceDataBg(SurfaceData srcData,
	515	SurfaceData dstData,
	516	int w, int h, Color bgColor)
	517	{
	518	SurfaceType srcType = srcData.getSurfaceType();
	519	SurfaceType dstType = dstData.getSurfaceType();
	520	BlitBg blitbg = BlitBg.getFromCache(srcType,
	521	CompositeType.SrcNoEa,
	522	dstType);
	523	blitbg.BlitBg(srcData, dstData,
	524	AlphaComposite.Src, null, bgColor.getRGB(),
	525	0, 0, 0, 0, w, h);
	526	dstData.markDirty();
	527	}
	528	}

java/pkg/sun/java2d/SurfaceManagerFactory.class+0−0

Binary file not shown.

java/pkg/sun/java2d/SurfaceManagerFactory.java+91−0

@@ -0,0 +1,91 @@
	1	/*
	2	* Copyright (c) 2003, 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;
	27
	28	import sun.awt.image.SunVolatileImage;
	29	import sun.awt.image.VolatileSurfaceManager;
	30
	31	/**
	32	* This factory creates platform specific VolatileSurfaceManager
	33	* implementations.
	34	*
	35	* There are two platform specific SurfaceManagerFactories in OpenJDK,
	36	* UnixSurfaceManagerFactory and WindowsSurfaceManagerFactory.
	37	* The actually used SurfaceManagerFactory is set by the respective platform
	38	* GraphicsEnvironment implementations in the static initializer.
	39	*/
	40	public abstract class SurfaceManagerFactory {
	41
	42	/**
	43	* The single shared instance.
	44	*/
	45	private static SurfaceManagerFactory instance;
	46
	47	/**
	48	* Returns the surface manager factory instance. This returns a factory
	49	* that has been set by {@link #setInstance(SurfaceManagerFactory)}.
	50	*
	51	* @return the surface manager factory
	52	*/
	53	public synchronized static SurfaceManagerFactory getInstance() {
	54
	55	if (instance == null) {
	56	throw new IllegalStateException("No SurfaceManagerFactory set.");
	57	}
	58	return instance;
	59	}
	60
	61	/**
	62	* Sets the surface manager factory. This may only be called once, and it
	63	* may not be set back to {@code null} when the factory is already
	64	* instantiated.
	65	*
	66	* @param factory the factory to set
	67	*/
	68	public synchronized static void setInstance(SurfaceManagerFactory factory) {
	69
	70	if (factory == null) {
	71	// We don't want to allow setting this to null at any time.
	72	throw new IllegalArgumentException("factory must be non-null");
	73	}
	74
	75	if (instance != null) {
	76	// We don't want to re-set the instance at any time.
	77	throw new IllegalStateException("The surface manager factory is already initialized");
	78	}
	79
	80	instance = factory;
	81	}
	82
	83	/**
	84	* Creates a new instance of a VolatileSurfaceManager given any
	85	* arbitrary SunVolatileImage. An optional context Object can be supplied
	86	* as a way for the caller to pass pipeline-specific context data to
	87	* the VolatileSurfaceManager (such as a backbuffer handle, for example).
	88	*/
	89	public abstract VolatileSurfaceManager
	90	createVolatileManager(SunVolatileImage image, Object context);
	91	}

java/pkg/sun/java2d/cmm/CMSManager$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/CMSManager$CMMTracer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/CMSManager.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/CMSManager.java+170−0

@@ -0,0 +1,170 @@
	1	/*
	2	* Copyright (c) 2006, 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.cmm;
	27
	28	import java.awt.color.ColorSpace;
	29	import java.awt.color.ICC_Profile;
	30	import java.awt.color.CMMException;
	31	import java.awt.image.BufferedImage;
	32	import java.awt.image.Raster;
	33	import java.awt.image.WritableRaster;
	34	import java.security.AccessController;
	35	import java.security.PrivilegedAction;
	36	import sun.security.action.GetPropertyAction;
	37	import java.util.ServiceLoader;
	38
	39	public class CMSManager {
	40	public static ColorSpace GRAYspace; // These two fields allow access
	41	public static ColorSpace LINEAR_RGBspace; // to java.awt.color.ColorSpace
	42	// private fields from other
	43	// packages. The fields are set
	44	// by java.awt.color.ColorSpace
	45	// and read by
	46	// java.awt.image.ColorModel.
	47
	48	private static PCMM cmmImpl = null;
	49
	50	public static synchronized PCMM getModule() {
	51	if (cmmImpl != null) {
	52	return cmmImpl;
	53	}
	54
	55	cmmImpl = (PCMM)AccessController.doPrivileged(new PrivilegedAction() {
	56	public Object run() {
	57	String cmmClass = System.getProperty(
	58	"sun.java2d.cmm", "sun.java2d.cmm.kcms.CMM");
	59
	60	ServiceLoader<PCMM> cmmLoader
	61	= ServiceLoader.loadInstalled(PCMM.class);
	62
	63	PCMM service = null;
	64
	65	for (PCMM cmm : cmmLoader) {
	66	service = cmm;
	67	if (cmm.getClass().getName().equals(cmmClass)) {
	68	break;
	69	}
	70	}
	71	return service;
	72	}
	73	});
	74
	75	if (cmmImpl == null) {
	76	throw new CMMException("Cannot initialize Color Management System."+
	77	"No CM module found");
	78	}
	79
	80	GetPropertyAction gpa = new GetPropertyAction("sun.java2d.cmm.trace");
	81	String cmmTrace = (String)AccessController.doPrivileged(gpa);
	82	if (cmmTrace != null) {
	83	cmmImpl = new CMMTracer(cmmImpl);
	84	}
	85
	86	return cmmImpl;
	87	}
	88
	89	/* CMM trace routines */
	90
	91	public static class CMMTracer implements PCMM {
	92	PCMM tcmm;
	93	String cName ;
	94
	95	public CMMTracer(PCMM tcmm) {
	96	this.tcmm = tcmm;
	97	cName = tcmm.getClass().getName();
	98	}
	99
	100	public long loadProfile(byte[] data) {
	101	System.err.print(cName + ".loadProfile");
	102	long profileID = tcmm.loadProfile(data);
	103	System.err.printf("(ID=%x)\n", profileID);
	104	return profileID;
	105	}
	106
	107	public void freeProfile(long profileID) {
	108	System.err.printf(cName + ".freeProfile(ID=%x)\n", profileID);
	109	tcmm.freeProfile(profileID);
	110	}
	111
	112	public int getProfileSize(long profileID) {
	113	System.err.print(cName + ".getProfileSize(ID=" + profileID + ")");
	114	int size = tcmm.getProfileSize(profileID);
	115	System.err.println("=" + size);
	116	return size;
	117	}
	118
	119	public void getProfileData(long profileID, byte[] data) {
	120	System.err.print(cName + ".getProfileData(ID=" + profileID + ") ");
	121	System.err.println("requested " + data.length + " byte(s)");
	122	tcmm.getProfileData(profileID, data);
	123	}
	124
	125	public int getTagSize(long profileID, int tagSignature) {
	126	System.err.printf(cName + ".getTagSize(ID=%x, TagSig=%s)",
	127	profileID, signatureToString(tagSignature));
	128	int size = tcmm.getTagSize(profileID, tagSignature);
	129	System.err.println("=" + size);
	130	return size;
	131	}
	132
	133	public void getTagData(long profileID, int tagSignature,
	134	byte[] data) {
	135	System.err.printf(cName + ".getTagData(ID=%x, TagSig=%s)",
	136	profileID, signatureToString(tagSignature));
	137	System.err.println(" requested " + data.length + " byte(s)");
	138	tcmm.getTagData(profileID, tagSignature, data);
	139	}
	140
	141	public void setTagData(long profileID, int tagSignature,
	142	byte[] data) {
	143	System.err.print(cName + ".setTagData(ID=" + profileID +
	144	", TagSig=" + tagSignature + ")");
	145	System.err.println(" sending " + data.length + " byte(s)");
	146	tcmm.setTagData(profileID, tagSignature, data);
	147	}
	148
	149	/* methods for creating ColorTransforms */
	150	public ColorTransform createTransform(ICC_Profile profile,
	151	int renderType,
	152	int transformType) {
	153	System.err.println(cName + ".createTransform(ICC_Profile,int,int)");
	154	return tcmm.createTransform(profile, renderType, transformType);
	155	}
	156
	157	public ColorTransform createTransform(ColorTransform[] transforms) {
	158	System.err.println(cName + ".createTransform(ColorTransform[])");
	159	return tcmm.createTransform(transforms);
	160	}
	161
	162	private static String signatureToString(int sig) {
	163	return String.format("%c%c%c%c",
	164	(char)(0xff & (sig >> 24)),
	165	(char)(0xff & (sig >> 16)),
	166	(char)(0xff & (sig >> 8)),
	167	(char)(0xff & (sig )));
	168	}
	169	}
	170	}

java/pkg/sun/java2d/cmm/ColorTransform.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/ColorTransform.java+53−0

@@ -0,0 +1,53 @@
	1	/*
	2	* Copyright (c) 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.cmm;
	27
	28	import java.awt.image.BufferedImage;
	29	import java.awt.image.Raster;
	30	import java.awt.image.WritableRaster;
	31
	32	public interface ColorTransform {
	33	public int Any = -1;/* any rendering type, whichever is
	34	available */
	35	/* search order is icPerceptual,
	36	icRelativeColorimetric, icSaturation */
	37
	38	/* Transform types */
	39	public int In = 1;
	40	public int Out = 2;
	41	public int Gamut = 3;
	42	public int Simulation = 4;
	43
	44	public int getNumInComponents();
	45	public int getNumOutComponents();
	46	public void colorConvert(BufferedImage src, BufferedImage dst);
	47	public void colorConvert(Raster src, WritableRaster dst,
	48	float[] srcMinVal, float[]srcMaxVal,
	49	float[] dstMinVal, float[]dstMaxVal);
	50	public void colorConvert(Raster src, WritableRaster dst);
	51	public short[] colorConvert(short[] src, short[] dest);
	52	public byte[] colorConvert (byte[] src, byte[] dest);
	53	}

java/pkg/sun/java2d/cmm/PCMM.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/PCMM.java+48−0

@@ -0,0 +1,48 @@
	1	/*
	2	* Copyright (c) 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.cmm;
	27
	28	import java.awt.color.ICC_Profile;
	29
	30	/* Pluggable CMM interface */
	31
	32	public interface PCMM {
	33
	34	/* methods invoked from ICC_Profile */
	35	public long loadProfile(byte[] data);
	36	public void freeProfile(long profileID);
	37	public int getProfileSize(long profileID);
	38	public void getProfileData(long profileID, byte[] data);
	39	public void getTagData(long profileID, int tagSignature, byte[] data);
	40	public int getTagSize(long profileID, int tagSignature);
	41	public void setTagData(long profileID, int tagSignature, byte[] data);
	42
	43	/* methods for creating ColorTransforms */
	44	public ColorTransform createTransform(ICC_Profile profile, int renderType,
	45	int transformType);
	46
	47	public ColorTransform createTransform(ColorTransform[] transforms);
	48	}

java/pkg/sun/java2d/cmm/ProfileActivator.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/ProfileActivator.java+41−0

@@ -0,0 +1,41 @@
	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.cmm;
	27
	28	import java.awt.color.ProfileDataException;
	29
	30	/**
	31	* An interface to allow the ProfileDeferralMgr to activate a
	32	* deferred profile.
	33	*/
	34	public interface ProfileActivator {
	35
	36	/**
	37	* Activate a previously deferred ICC_Profile object.
	38	*/
	39	public void activate() throws ProfileDataException;
	40
	41	}

java/pkg/sun/java2d/cmm/ProfileDeferralInfo.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/ProfileDeferralInfo.java+61−0

@@ -0,0 +1,61 @@
	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.cmm;
	27
	28	import java.io.InputStream;
	29	import java.io.IOException;
	30
	31
	32	/**
	33	* A class to pass information about a profile to be loaded from
	34	* a file to the static getInstance(InputStream) method of
	35	* ICC_Profile. Loading of the profile data and initialization
	36	* of the CMM is to be deferred as long as possible.
	37	*/
	38	public class ProfileDeferralInfo extends InputStream {
	39
	40	public int colorSpaceType, numComponents, profileClass;
	41	public String filename;
	42
	43	public ProfileDeferralInfo(String fn, int type, int ncomp, int pclass) {
	44
	45	super();
	46	filename = fn;
	47	colorSpaceType = type;
	48	numComponents = ncomp;
	49	profileClass = pclass;
	50	}
	51
	52
	53	/**
	54	* Implements the abstract read() method of InputStream.
	55	*/
	56	public int read() throws IOException {
	57
	58	return 0;
	59	}
	60
	61	}

java/pkg/sun/java2d/cmm/ProfileDeferralMgr.class+0−0

Binary file not shown.

java/pkg/sun/java2d/cmm/ProfileDeferralMgr.java+119−0

@@ -0,0 +1,119 @@
	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.cmm;
	27
	28	import java.awt.color.ProfileDataException;
	29	import java.util.Vector;
	30
	31
	32	/**
	33	* A class to manage the deferral of CMM initialization of profile
	34	* data for internal ICC_Profile objects - i.e. when we "trust" that
	35	* the profile data is valid and we think it may not be needed. An
	36	* example is the sRGB profile which gets loaded by any program doing
	37	* graphics, but which may not be needed if the program does not need
	38	* high quality color conversion.
	39	*/
	40	public class ProfileDeferralMgr {
	41
	42	public static boolean deferring = true;
	43	private static Vector<ProfileActivator> aVector;
	44
	45	/**
	46	* Records a ProfileActivator object whose activate method will
	47	* be called if the CMM needs to be activated.
	48	*/
	49	public static void registerDeferral(ProfileActivator pa) {
	50
	51	if (!deferring) {
	52	return;
	53	}
	54	if (aVector == null) {
	55	aVector = new Vector<ProfileActivator>(3, 3);
	56	}
	57	aVector.addElement(pa);
	58	return;
	59	}
	60
	61
	62	/**
	63	* Removes a ProfileActivator object from the vector of ProfileActivator
	64	* objects whose activate method will be called if the CMM needs to be
	65	* activated.
	66	*/
	67	public static void unregisterDeferral(ProfileActivator pa) {
	68
	69	if (!deferring) {
	70	return;
	71	}
	72	if (aVector == null) {
	73	return;
	74	}
	75	aVector.removeElement(pa);
	76	return;
	77	}
	78
	79	/**
	80	* Removes a ProfileActivator object from the vector of ProfileActivator
	81	* objects whose activate method will be called if the CMM needs to be
	82	* activated.
	83	*/
	84	public static void activateProfiles() {
	85
	86	int i, n;
	87
	88	deferring = false;
	89	if (aVector == null) {
	90	return;
	91	}
	92	n = aVector.size();
	93	for (ProfileActivator pa : aVector) {
	94	try {
	95	pa.activate();
	96	} catch (ProfileDataException e) {
	97	/*
	98	* Ignore profile activation error for now:
	99	* such exception is pssible due to absence
	100	* or corruption of standard color profile.
	101	* As for now we expect all profiles should
	102	* be shiped with jre and presence of this
	103	* exception is indication of some configuration
	104	* problem in jre installation.
	105	*
	106	* NB: we still are greedy loading deferred profiles
	107	* and load them all if any of them is needed.
	108	* Therefore broken profile (if any) might be never used.
	109	* If there will be attempt to use broken profile then
	110	* it will result in CMMException.
	111	*/
	112	}
	113	}
	114	aVector.removeAllElements();
	115	aVector = null;
	116	return;
	117	}
	118
	119	}

java/pkg/sun/java2d/cmm/lcms/LCMS.java+104−0

@@ -0,0 +1,104 @@
	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.cmm.lcms;
	27
	28	import java.awt.color.ColorSpace;
	29	import java.awt.color.ICC_Profile;
	30	import java.awt.color.CMMException;
	31	import sun.java2d.cmm.ColorTransform;
	32	import sun.java2d.cmm.PCMM;
	33	import sun.java2d.cmm.lcms.LCMS;
	34	import sun.java2d.cmm.lcms.LCMSTransform;
	35
	36	public class LCMS implements PCMM {
	37
	38	/* methods invoked from ICC_Profile */
	39	public native long loadProfile(byte[] data);
	40
	41	public native void freeProfile(long profileID);
	42
	43	public native synchronized int getProfileSize(long profileID);
	44
	45	public native synchronized void getProfileData(long profileID, byte[] data);
	46
	47	public native synchronized int getTagSize(long profileID, int tagSignature);
	48	public native synchronized void getTagData(long profileID, int tagSignature,
	49	byte[] data);
	50	public native synchronized void setTagData(long profileID, int tagSignature,
	51	byte[] data);
	52
	53	public static native long getProfileID(ICC_Profile profile);
	54
	55	public static native long createNativeTransform(
	56	long[] profileIDs, int renderType, int inFormatter, int outFormatter,
	57	Object disposerRef);
	58
	59	/**
	60	* Constructs ColorTransform object corresponding to an ICC_profile
	61	*/
	62	public ColorTransform createTransform(ICC_Profile profile,
	63	int renderType,
	64	int transformType)
	65	{
	66	return new LCMSTransform(profile, renderType, renderType);
	67	}
	68
	69	/**
	70	* Constructs an ColorTransform object from a list of ColorTransform
	71	* objects
	72	*/
	73	public synchronized ColorTransform createTransform(
	74	ColorTransform[] transforms)
	75	{
	76	return new LCMSTransform(transforms);
	77	}
	78
	79	/* methods invoked from LCMSTransform */
	80	public static native void colorConvert(LCMSTransform trans,
	81	LCMSImageLayout src,
	82	LCMSImageLayout dest);
	83	public static native void freeTransform(long ID);
	84
	85	public static native void initLCMS(Class Trans, Class IL, Class Pf);
	86
	87	/* the class initializer which loads the CMM */
	88	static {
	89	java.security.AccessController.doPrivileged(
	90	new java.security.PrivilegedAction() {
	91	public Object run() {
	92	/* We need to load awt here because of usage trace and
	93	* disposer frameworks
	94	*/
	95	System.loadLibrary("awt");
	96	System.loadLibrary("lcms");
	97	return null;
	98	}
	99	}
	100	);
	101
	102	initLCMS(LCMSTransform.class, LCMSImageLayout.class, ICC_Profile.class);
	103	}
	104	}

java/pkg/sun/java2d/cmm/lcms/LCMSImageLayout.java+235−0

@@ -0,0 +1,235 @@
	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.cmm.lcms;
	27
	28	import java.awt.Graphics2D;
	29	import java.awt.image.BufferedImage;
	30	import java.awt.image.ComponentColorModel;
	31	import java.awt.image.Raster;
	32	import java.awt.image.WritableRaster;
	33	import java.awt.image.SinglePixelPackedSampleModel;
	34	import java.awt.image.ComponentSampleModel;
	35	import java.awt.image.DataBuffer;
	36	import java.awt.image.DataBufferByte;
	37	import java.awt.image.DataBufferUShort;
	38	import java.awt.image.DataBufferInt;
	39	import java.awt.image.ColorModel;
	40	import sun.awt.image.ByteComponentRaster;
	41	import sun.awt.image.ShortComponentRaster;
	42	import sun.awt.image.IntegerComponentRaster;
	43
	44
	45	class LCMSImageLayout {
	46
	47	public static int BYTES_SH(int x) {
	48	return x;
	49	}
	50
	51	public static int EXTRA_SH(int x) {
	52	return x<<7;
	53	}
	54
	55	public static int CHANNELS_SH(int x) {
	56	return x<<3;
	57	}
	58
	59	public static final int SWAPFIRST = 1<<14;
	60
	61	public static final int DOSWAP = 1<<10;
	62
	63	public static final int PT_RGB_8 =
	64	CHANNELS_SH(3) \| BYTES_SH(1);
	65
	66	public static final int PT_GRAY_8 =
	67	CHANNELS_SH(1) \| BYTES_SH(1);
	68
	69	public static final int PT_GRAY_16 =
	70	CHANNELS_SH(1) \| BYTES_SH(2);
	71
	72	public static final int PT_RGBA_8 =
	73	EXTRA_SH(1) \| CHANNELS_SH(3) \| BYTES_SH(1);
	74
	75	public static final int PT_ARGB_8 =
	76	EXTRA_SH(1) \| CHANNELS_SH(3) \| BYTES_SH(1) \| SWAPFIRST;
	77
	78	public static final int PT_BGR_8 =
	79	DOSWAP \| CHANNELS_SH(3) \| BYTES_SH(1);
	80
	81	public static final int PT_ABGR_8 =
	82	DOSWAP \| EXTRA_SH(1) \| CHANNELS_SH(3) \| BYTES_SH(1);
	83
	84	public static final int PT_BGRA_8 = EXTRA_SH(1) \| CHANNELS_SH(3) \|
	85	BYTES_SH(1) \| DOSWAP \| SWAPFIRST;
	86
	87	public static final int DT_BYTE = 0;
	88	public static final int DT_SHORT = 1;
	89	public static final int DT_INT = 2;
	90	public static final int DT_DOUBLE = 3;
	91
	92
	93	boolean isIntPacked = false;
	94	int pixelType;
	95	int dataType;
	96	int width;
	97	int height;
	98	int nextRowOffset;
	99	int offset;
	100
	101	Object dataArray;
	102	private LCMSImageLayout(int np, int pixelType, int pixelSize) {
	103	this.pixelType = pixelType;
	104	width = np;
	105	height = 1;
	106	nextRowOffset = np*pixelSize;
	107	offset = 0;
	108	}
	109
	110	private LCMSImageLayout(int width, int height, int pixelType,
	111	int pixelSize) {
	112	this.pixelType = pixelType;
	113	this.width = width;
	114	this.height = height;
	115	nextRowOffset = width*pixelSize;
	116	offset = 0;
	117	}
	118
	119
	120	public LCMSImageLayout(byte[] data, int np, int pixelType, int pixelSize) {
	121	this(np, pixelType, pixelSize);
	122	dataType = DT_BYTE;
	123	dataArray = data;
	124	}
	125
	126	public LCMSImageLayout(short[] data, int np, int pixelType, int pixelSize) {
	127	this(np, pixelType, pixelSize);
	128	dataType = DT_SHORT;
	129	dataArray = data;
	130	}
	131
	132	public LCMSImageLayout(int[] data, int np, int pixelType, int pixelSize) {
	133	this(np, pixelType, pixelSize);
	134	dataType = DT_INT;
	135	dataArray = data;
	136	}
	137
	138	public LCMSImageLayout(double[] data, int np, int pixelType, int pixelSize)
	139	{
	140	this(np, pixelType, pixelSize);
	141	dataType = DT_DOUBLE;
	142	dataArray = data;
	143	}
	144
	145	public LCMSImageLayout(BufferedImage image) {
	146	ShortComponentRaster shortRaster;
	147	IntegerComponentRaster intRaster;
	148	ByteComponentRaster byteRaster;
	149	switch (image.getType()) {
	150	case BufferedImage.TYPE_INT_RGB:
	151	pixelType = PT_ARGB_8;
	152	isIntPacked = true;
	153	break;
	154	case BufferedImage.TYPE_INT_ARGB:
	155	pixelType = PT_ARGB_8;
	156	isIntPacked = true;
	157	break;
	158	case BufferedImage.TYPE_INT_BGR:
	159	pixelType = PT_ABGR_8;
	160	isIntPacked = true;
	161	break;
	162	case BufferedImage.TYPE_3BYTE_BGR:
	163	pixelType = PT_BGR_8;
	164	break;
	165	case BufferedImage.TYPE_4BYTE_ABGR:
	166	pixelType = PT_ABGR_8;
	167	break;
	168	case BufferedImage.TYPE_BYTE_GRAY:
	169	pixelType = PT_GRAY_8;
	170	break;
	171	case BufferedImage.TYPE_USHORT_GRAY:
	172	pixelType = PT_GRAY_16;
	173	break;
	174	default:
	175	// TODO: Add support for some images having
	176	// SinglePixelPackedModel and ComponentSampleModel
	177	throw new IllegalArgumentException(
	178	"CMMImageLayout - bad image type passed to constructor");
	179	}
	180
	181	width = image.getWidth();
	182	height = image.getHeight();
	183
	184	switch (image.getType()) {
	185	case BufferedImage.TYPE_INT_RGB:
	186	case BufferedImage.TYPE_INT_ARGB:
	187	case BufferedImage.TYPE_INT_BGR:
	188	intRaster = (IntegerComponentRaster)image.getRaster();
	189	nextRowOffset = intRaster.getScanlineStride()*4;
	190	offset = intRaster.getDataOffset(0)*4;
	191	dataArray = intRaster.getDataStorage();
	192	dataType = DT_INT;
	193	break;
	194
	195	case BufferedImage.TYPE_3BYTE_BGR:
	196	case BufferedImage.TYPE_4BYTE_ABGR:
	197	byteRaster = (ByteComponentRaster)image.getRaster();
	198	nextRowOffset = byteRaster.getScanlineStride();
	199	offset = byteRaster.getDataOffset(0);
	200	dataArray = byteRaster.getDataStorage();
	201	dataType = DT_BYTE;
	202	break;
	203
	204	case BufferedImage.TYPE_BYTE_GRAY:
	205	byteRaster = (ByteComponentRaster)image.getRaster();
	206	nextRowOffset = byteRaster.getScanlineStride();
	207	offset = byteRaster.getDataOffset(0);
	208	dataArray = byteRaster.getDataStorage();
	209	dataType = DT_BYTE;
	210	break;
	211
	212	case BufferedImage.TYPE_USHORT_GRAY:
	213	shortRaster = (ShortComponentRaster)image.getRaster();
	214	nextRowOffset = shortRaster.getScanlineStride()*2;
	215	offset = shortRaster.getDataOffset(0) * 2;
	216	dataArray = shortRaster.getDataStorage();
	217	dataType = DT_SHORT;
	218	break;
	219	}
	220	}
	221
	222	public static boolean isSupported(BufferedImage image) {
	223	switch (image.getType()) {
	224	case BufferedImage.TYPE_INT_RGB:
	225	case BufferedImage.TYPE_INT_ARGB:
	226	case BufferedImage.TYPE_INT_BGR:
	227	case BufferedImage.TYPE_3BYTE_BGR:
	228	case BufferedImage.TYPE_4BYTE_ABGR:
	229	case BufferedImage.TYPE_BYTE_GRAY:
	230	case BufferedImage.TYPE_USHORT_GRAY:
	231	return true;
	232	}
	233	return false;
	234	}
	235	}

java/pkg/sun/java2d/cmm/lcms/LCMSTransform.java+609−0

@@ -0,0 +1,609 @@
	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	/**********************************************************************
	27	**********************************************************************
	28	**********************************************************************
	29	* COPYRIGHT (c) Eastman Kodak Company, 1997 *
	30	* As an unpublished work pursuant to Title 17 of the United *
	31	* States Code. All rights reserved. *
	32	**********************************************************************
	33	**********************************************************************
	34	**********************************************************************/
	35
	36	package sun.java2d.cmm.lcms;
	37
	38	import java.awt.color.ICC_Profile;
	39	import java.awt.color.ProfileDataException;
	40	import java.awt.color.CMMException;
	41	import java.awt.color.ColorSpace;
	42	import java.awt.image.BufferedImage;
	43	import java.awt.image.Raster;
	44	import java.awt.image.WritableRaster;
	45	import java.awt.image.ColorModel;
	46	import java.awt.image.DirectColorModel;
	47	import java.awt.image.ComponentColorModel;
	48	import java.awt.image.SampleModel;
	49	import java.awt.image.DataBuffer;
	50	import java.awt.image.SinglePixelPackedSampleModel;
	51	import java.awt.image.ComponentSampleModel;
	52	import sun.java2d.cmm.*;
	53	import sun.java2d.cmm.lcms.*;
	54
	55
	56	public class LCMSTransform implements ColorTransform {
	57	long ID;
	58	private int inFormatter;
	59	private int outFormatter;
	60
	61	ICC_Profile[] profiles;
	62	long [] profileIDs;
	63	int renderType;
	64	int transformType;
	65
	66	private int numInComponents = -1;
	67	private int numOutComponents = -1;
	68
	69	private Object disposerReferent = new Object();
	70
	71	/* the class initializer */
	72	static {
	73	if (ProfileDeferralMgr.deferring) {
	74	ProfileDeferralMgr.activateProfiles();
	75	}
	76	}
	77
	78	public LCMSTransform(ICC_Profile profile, int renderType,
	79	int transformType)
	80	{
	81	/* Actually, it is not a complete transform but just part of it */
	82	profiles = new ICC_Profile[1];
	83	profiles[0] = profile;
	84	profileIDs = new long[1];
	85	profileIDs[0] = LCMS.getProfileID(profile);
	86	this.renderType = (renderType == ColorTransform.Any)?
	87	ICC_Profile.icPerceptual : renderType;
	88	this.transformType = transformType;
	89
	90	/* Note that ICC_Profile.getNumComponents() is quite expensive
	91	* (it may results in a reading of the profile header).
	92	* So, here we cache the number of components of input and
	93	* output profiles for further usage.
	94	*/
	95	numInComponents = profiles[0].getNumComponents();
	96	numOutComponents = profiles[profiles.length - 1].getNumComponents();
	97	}
	98
	99	public LCMSTransform (ColorTransform[] transforms) {
	100	int size = 0;
	101	for (int i=0; i < transforms.length; i++) {
	102	size+=((LCMSTransform)transforms[i]).profiles.length;
	103	}
	104	profiles = new ICC_Profile[size];
	105	profileIDs = new long[size];
	106	int j = 0;
	107	for (int i=0; i < transforms.length; i++) {
	108	LCMSTransform curTrans = (LCMSTransform)transforms[i];
	109	System.arraycopy(curTrans.profiles, 0, profiles, j,
	110	curTrans.profiles.length);
	111	System.arraycopy(curTrans.profileIDs, 0, profileIDs, j,
	112	curTrans.profileIDs.length);
	113	j += curTrans.profiles.length;
	114	}
	115	renderType = ((LCMSTransform)transforms[0]).renderType;
	116
	117	/* Note that ICC_Profile.getNumComponents() is quite expensive
	118	* (it may results in a reading of the profile header).
	119	* So, here we cache the number of components of input and
	120	* output profiles for further usage.
	121	*/
	122	numInComponents = profiles[0].getNumComponents();
	123	numOutComponents = profiles[profiles.length - 1].getNumComponents();
	124	}
	125
	126	public int getNumInComponents() {
	127	return numInComponents;
	128	}
	129
	130	public int getNumOutComponents() {
	131	return numOutComponents;
	132	}
	133
	134	private synchronized void doTransform(LCMSImageLayout in,
	135	LCMSImageLayout out) {
	136	// update native transfrom if needed
	137	if (ID == 0L \|\|
	138	inFormatter != in.pixelType \|\|
	139	outFormatter != out.pixelType) {
	140
	141	if (ID != 0L) {
	142	// Disposer will destroy forgotten transform
	143	disposerReferent = new Object();
	144	}
	145	inFormatter = in.pixelType;
	146	outFormatter = out.pixelType;
	147
	148	ID = LCMS.createNativeTransform(profileIDs, renderType,
	149	inFormatter, outFormatter,
	150	disposerReferent);
	151	}
	152
	153	LCMS.colorConvert(this, in, out);
	154	}
	155
	156	public void colorConvert(BufferedImage src, BufferedImage dst) {
	157	if (LCMSImageLayout.isSupported(src) &&
	158	LCMSImageLayout.isSupported(dst))
	159	{
	160	doTransform(new LCMSImageLayout(src), new LCMSImageLayout(dst));
	161	return;
	162	}
	163	LCMSImageLayout srcIL, dstIL;
	164	Raster srcRas = src.getRaster();
	165	WritableRaster dstRas = dst.getRaster();
	166	ColorModel srcCM = src.getColorModel();
	167	ColorModel dstCM = dst.getColorModel();
	168	int w = src.getWidth();
	169	int h = src.getHeight();
	170	int srcNumComp = srcCM.getNumColorComponents();
	171	int dstNumComp = dstCM.getNumColorComponents();
	172	int precision = 8;
	173	float maxNum = 255.0f;
	174	for (int i = 0; i < srcNumComp; i++) {
	175	if (srcCM.getComponentSize(i) > 8) {
	176	precision = 16;
	177	maxNum = 65535.0f;
	178	}
	179	}
	180	for (int i = 0; i < dstNumComp; i++) {
	181	if (dstCM.getComponentSize(i) > 8) {
	182	precision = 16;
	183	maxNum = 65535.0f;
	184	}
	185	}
	186	float[] srcMinVal = new float[srcNumComp];
	187	float[] srcInvDiffMinMax = new float[srcNumComp];
	188	ColorSpace cs = srcCM.getColorSpace();
	189	for (int i = 0; i < srcNumComp; i++) {
	190	srcMinVal[i] = cs.getMinValue(i);
	191	srcInvDiffMinMax[i] = maxNum / (cs.getMaxValue(i) - srcMinVal[i]);
	192	}
	193	cs = dstCM.getColorSpace();
	194	float[] dstMinVal = new float[dstNumComp];
	195	float[] dstDiffMinMax = new float[dstNumComp];
	196	for (int i = 0; i < dstNumComp; i++) {
	197	dstMinVal[i] = cs.getMinValue(i);
	198	dstDiffMinMax[i] = (cs.getMaxValue(i) - dstMinVal[i]) / maxNum;
	199	}
	200	boolean dstHasAlpha = dstCM.hasAlpha();
	201	boolean needSrcAlpha = srcCM.hasAlpha() && dstHasAlpha;
	202	float[] dstColor;
	203	if (dstHasAlpha) {
	204	dstColor = new float[dstNumComp + 1];
	205	} else {
	206	dstColor = new float[dstNumComp];
	207	}
	208	if (precision == 8) {
	209	byte[] srcLine = new byte[w * srcNumComp];
	210	byte[] dstLine = new byte[w * dstNumComp];
	211	Object pixel;
	212	float[] color;
	213	float[] alpha = null;
	214	if (needSrcAlpha) {
	215	alpha = new float[w];
	216	}
	217	int idx;
	218	// TODO check for src npixels = dst npixels
	219	srcIL = new LCMSImageLayout(
	220	srcLine, srcLine.length/getNumInComponents(),
	221	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	222	LCMSImageLayout.BYTES_SH(1), getNumInComponents());
	223	dstIL = new LCMSImageLayout(
	224	dstLine, dstLine.length/getNumOutComponents(),
	225	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	226	LCMSImageLayout.BYTES_SH(1), getNumOutComponents());
	227	// process each scanline
	228	for (int y = 0; y < h; y++) {
	229	// convert src scanline
	230	pixel = null;
	231	color = null;
	232	idx = 0;
	233	for (int x = 0; x < w; x++) {
	234	pixel = srcRas.getDataElements(x, y, pixel);
	235	color = srcCM.getNormalizedComponents(pixel, color, 0);
	236	for (int i = 0; i < srcNumComp; i++) {
	237	srcLine[idx++] = (byte)
	238	((color[i] - srcMinVal[i]) * srcInvDiffMinMax[i] +
	239	0.5f);
	240	}
	241	if (needSrcAlpha) {
	242	alpha[x] = color[srcNumComp];
	243	}
	244	}
	245	// color convert srcLine to dstLine
	246	doTransform(srcIL, dstIL);
	247
	248	// convert dst scanline
	249	pixel = null;
	250	idx = 0;
	251	for (int x = 0; x < w; x++) {
	252	for (int i = 0; i < dstNumComp; i++) {
	253	dstColor[i] = ((float) (dstLine[idx++] & 0xff)) *
	254	dstDiffMinMax[i] + dstMinVal[i];
	255	}
	256	if (needSrcAlpha) {
	257	dstColor[dstNumComp] = alpha[x];
	258	} else if (dstHasAlpha) {
	259	dstColor[dstNumComp] = 1.0f;
	260	}
	261	pixel = dstCM.getDataElements(dstColor, 0, pixel);
	262	dstRas.setDataElements(x, y, pixel);
	263	}
	264	}
	265	} else {
	266	short[] srcLine = new short[w * srcNumComp];
	267	short[] dstLine = new short[w * dstNumComp];
	268	Object pixel;
	269	float[] color;
	270	float[] alpha = null;
	271	if (needSrcAlpha) {
	272	alpha = new float[w];
	273	}
	274	int idx;
	275	srcIL = new LCMSImageLayout(
	276	srcLine, srcLine.length/getNumInComponents(),
	277	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	278	LCMSImageLayout.BYTES_SH(2), getNumInComponents()*2);
	279
	280	dstIL = new LCMSImageLayout(
	281	dstLine, dstLine.length/getNumOutComponents(),
	282	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	283	LCMSImageLayout.BYTES_SH(2), getNumOutComponents()*2);
	284
	285	// process each scanline
	286	for (int y = 0; y < h; y++) {
	287	// convert src scanline
	288	pixel = null;
	289	color = null;
	290	idx = 0;
	291	for (int x = 0; x < w; x++) {
	292	pixel = srcRas.getDataElements(x, y, pixel);
	293	color = srcCM.getNormalizedComponents(pixel, color, 0);
	294	for (int i = 0; i < srcNumComp; i++) {
	295	srcLine[idx++] = (short)
	296	((color[i] - srcMinVal[i]) * srcInvDiffMinMax[i] +
	297	0.5f);
	298	}
	299	if (needSrcAlpha) {
	300	alpha[x] = color[srcNumComp];
	301	}
	302	}
	303	// color convert srcLine to dstLine
	304	doTransform(srcIL, dstIL);
	305
	306	// convert dst scanline
	307	pixel = null;
	308	idx = 0;
	309	for (int x = 0; x < w; x++) {
	310	for (int i = 0; i < dstNumComp; i++) {
	311	dstColor[i] = ((float) (dstLine[idx++] & 0xffff)) *
	312	dstDiffMinMax[i] + dstMinVal[i];
	313	}
	314	if (needSrcAlpha) {
	315	dstColor[dstNumComp] = alpha[x];
	316	} else if (dstHasAlpha) {
	317	dstColor[dstNumComp] = 1.0f;
	318	}
	319	pixel = dstCM.getDataElements(dstColor, 0, pixel);
	320	dstRas.setDataElements(x, y, pixel);
	321	}
	322	}
	323	}
	324	}
	325
	326	public void colorConvert(Raster src, WritableRaster dst,
	327	float[] srcMinVal, float[]srcMaxVal,
	328	float[] dstMinVal, float[]dstMaxVal) {
	329	LCMSImageLayout srcIL, dstIL;
	330
	331	// Can't pass src and dst directly to CMM, so process per scanline
	332	SampleModel srcSM = src.getSampleModel();
	333	SampleModel dstSM = dst.getSampleModel();
	334	int srcTransferType = src.getTransferType();
	335	int dstTransferType = dst.getTransferType();
	336	boolean srcIsFloat, dstIsFloat;
	337	if ((srcTransferType == DataBuffer.TYPE_FLOAT) \|\|
	338	(srcTransferType == DataBuffer.TYPE_DOUBLE)) {
	339	srcIsFloat = true;
	340	} else {
	341	srcIsFloat = false;
	342	}
	343	if ((dstTransferType == DataBuffer.TYPE_FLOAT) \|\|
	344	(dstTransferType == DataBuffer.TYPE_DOUBLE)) {
	345	dstIsFloat = true;
	346	} else {
	347	dstIsFloat = false;
	348	}
	349	int w = src.getWidth();
	350	int h = src.getHeight();
	351	int srcNumBands = src.getNumBands();
	352	int dstNumBands = dst.getNumBands();
	353	float[] srcScaleFactor = new float[srcNumBands];
	354	float[] dstScaleFactor = new float[dstNumBands];
	355	float[] srcUseMinVal = new float[srcNumBands];
	356	float[] dstUseMinVal = new float[dstNumBands];
	357	for (int i = 0; i < srcNumBands; i++) {
	358	if (srcIsFloat) {
	359	srcScaleFactor[i] = 65535.0f / (srcMaxVal[i] - srcMinVal[i]);
	360	srcUseMinVal[i] = srcMinVal[i];
	361	} else {
	362	if (srcTransferType == DataBuffer.TYPE_SHORT) {
	363	srcScaleFactor[i] = 65535.0f / 32767.0f;
	364	} else {
	365	srcScaleFactor[i] = 65535.0f /
	366	((float) ((1 << srcSM.getSampleSize(i)) - 1));
	367	}
	368	srcUseMinVal[i] = 0.0f;
	369	}
	370	}
	371	for (int i = 0; i < dstNumBands; i++) {
	372	if (dstIsFloat) {
	373	dstScaleFactor[i] = (dstMaxVal[i] - dstMinVal[i]) / 65535.0f;
	374	dstUseMinVal[i] = dstMinVal[i];
	375	} else {
	376	if (dstTransferType == DataBuffer.TYPE_SHORT) {
	377	dstScaleFactor[i] = 32767.0f / 65535.0f;
	378	} else {
	379	dstScaleFactor[i] =
	380	((float) ((1 << dstSM.getSampleSize(i)) - 1)) /
	381	65535.0f;
	382	}
	383	dstUseMinVal[i] = 0.0f;
	384	}
	385	}
	386	int ys = src.getMinY();
	387	int yd = dst.getMinY();
	388	int xs, xd;
	389	float sample;
	390	short[] srcLine = new short[w * srcNumBands];
	391	short[] dstLine = new short[w * dstNumBands];
	392	int idx;
	393	srcIL = new LCMSImageLayout(
	394	srcLine, srcLine.length/getNumInComponents(),
	395	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	396	LCMSImageLayout.BYTES_SH(2), getNumInComponents()*2);
	397
	398	dstIL = new LCMSImageLayout(
	399	dstLine, dstLine.length/getNumOutComponents(),
	400	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	401	LCMSImageLayout.BYTES_SH(2), getNumOutComponents()*2);
	402
	403	// process each scanline
	404	for (int y = 0; y < h; y++, ys++, yd++) {
	405	// get src scanline
	406	xs = src.getMinX();
	407	idx = 0;
	408	for (int x = 0; x < w; x++, xs++) {
	409	for (int i = 0; i < srcNumBands; i++) {
	410	sample = src.getSampleFloat(xs, ys, i);
	411	srcLine[idx++] = (short)
	412	((sample - srcUseMinVal[i]) * srcScaleFactor[i] + 0.5f);
	413	}
	414	}
	415
	416	// color convert srcLine to dstLine
	417	doTransform(srcIL, dstIL);
	418
	419	// store dst scanline
	420	xd = dst.getMinX();
	421	idx = 0;
	422	for (int x = 0; x < w; x++, xd++) {
	423	for (int i = 0; i < dstNumBands; i++) {
	424	sample = ((dstLine[idx++] & 0xffff) * dstScaleFactor[i]) +
	425	dstUseMinVal[i];
	426	dst.setSample(xd, yd, i, sample);
	427	}
	428	}
	429	}
	430	}
	431
	432	public void colorConvert(Raster src, WritableRaster dst) {
	433
	434	LCMSImageLayout srcIL, dstIL;
	435	// Can't pass src and dst directly to CMM, so process per scanline
	436	SampleModel srcSM = src.getSampleModel();
	437	SampleModel dstSM = dst.getSampleModel();
	438	int srcTransferType = src.getTransferType();
	439	int dstTransferType = dst.getTransferType();
	440	int w = src.getWidth();
	441	int h = src.getHeight();
	442	int srcNumBands = src.getNumBands();
	443	int dstNumBands = dst.getNumBands();
	444	int precision = 8;
	445	float maxNum = 255.0f;
	446	for (int i = 0; i < srcNumBands; i++) {
	447	if (srcSM.getSampleSize(i) > 8) {
	448	precision = 16;
	449	maxNum = 65535.0f;
	450	}
	451	}
	452	for (int i = 0; i < dstNumBands; i++) {
	453	if (dstSM.getSampleSize(i) > 8) {
	454	precision = 16;
	455	maxNum = 65535.0f;
	456	}
	457	}
	458	float[] srcScaleFactor = new float[srcNumBands];
	459	float[] dstScaleFactor = new float[dstNumBands];
	460	for (int i = 0; i < srcNumBands; i++) {
	461	if (srcTransferType == DataBuffer.TYPE_SHORT) {
	462	srcScaleFactor[i] = maxNum / 32767.0f;
	463	} else {
	464	srcScaleFactor[i] = maxNum /
	465	((float) ((1 << srcSM.getSampleSize(i)) - 1));
	466	}
	467	}
	468	for (int i = 0; i < dstNumBands; i++) {
	469	if (dstTransferType == DataBuffer.TYPE_SHORT) {
	470	dstScaleFactor[i] = 32767.0f / maxNum;
	471	} else {
	472	dstScaleFactor[i] =
	473	((float) ((1 << dstSM.getSampleSize(i)) - 1)) / maxNum;
	474	}
	475	}
	476	int ys = src.getMinY();
	477	int yd = dst.getMinY();
	478	int xs, xd;
	479	int sample;
	480	if (precision == 8) {
	481	byte[] srcLine = new byte[w * srcNumBands];
	482	byte[] dstLine = new byte[w * dstNumBands];
	483	int idx;
	484	// TODO check for src npixels = dst npixels
	485	srcIL = new LCMSImageLayout(
	486	srcLine, srcLine.length/getNumInComponents(),
	487	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	488	LCMSImageLayout.BYTES_SH(1), getNumInComponents());
	489	dstIL = new LCMSImageLayout(
	490	dstLine, dstLine.length/getNumOutComponents(),
	491	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	492	LCMSImageLayout.BYTES_SH(1), getNumOutComponents());
	493
	494	// process each scanline
	495	for (int y = 0; y < h; y++, ys++, yd++) {
	496	// get src scanline
	497	xs = src.getMinX();
	498	idx = 0;
	499	for (int x = 0; x < w; x++, xs++) {
	500	for (int i = 0; i < srcNumBands; i++) {
	501	sample = src.getSample(xs, ys, i);
	502	srcLine[idx++] = (byte)
	503	((sample * srcScaleFactor[i]) + 0.5f);
	504	}
	505	}
	506
	507	// color convert srcLine to dstLine
	508	doTransform(srcIL, dstIL);
	509
	510	// store dst scanline
	511	xd = dst.getMinX();
	512	idx = 0;
	513	for (int x = 0; x < w; x++, xd++) {
	514	for (int i = 0; i < dstNumBands; i++) {
	515	sample = (int) (((dstLine[idx++] & 0xff) *
	516	dstScaleFactor[i]) + 0.5f);
	517	dst.setSample(xd, yd, i, sample);
	518	}
	519	}
	520	}
	521	} else {
	522	short[] srcLine = new short[w * srcNumBands];
	523	short[] dstLine = new short[w * dstNumBands];
	524	int idx;
	525	srcIL = new LCMSImageLayout(
	526	srcLine, srcLine.length/getNumInComponents(),
	527	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	528	LCMSImageLayout.BYTES_SH(2), getNumInComponents()*2);
	529
	530	dstIL = new LCMSImageLayout(
	531	dstLine, dstLine.length/getNumOutComponents(),
	532	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	533	LCMSImageLayout.BYTES_SH(2), getNumOutComponents()*2);
	534
	535	// process each scanline
	536	for (int y = 0; y < h; y++, ys++, yd++) {
	537	// get src scanline
	538	xs = src.getMinX();
	539	idx = 0;
	540	for (int x = 0; x < w; x++, xs++) {
	541	for (int i = 0; i < srcNumBands; i++) {
	542	sample = src.getSample(xs, ys, i);
	543	srcLine[idx++] = (short)
	544	((sample * srcScaleFactor[i]) + 0.5f);
	545	}
	546	}
	547
	548	// color convert srcLine to dstLine
	549	doTransform(srcIL, dstIL);
	550
	551	// store dst scanline
	552	xd = dst.getMinX();
	553	idx = 0;
	554	for (int x = 0; x < w; x++, xd++) {
	555	for (int i = 0; i < dstNumBands; i++) {
	556	sample = (int) (((dstLine[idx++] & 0xffff) *
	557	dstScaleFactor[i]) + 0.5f);
	558	dst.setSample(xd, yd, i, sample);
	559	}
	560	}
	561	}
	562	}
	563	}
	564
	565	/* convert an array of colors in short format */
	566	/* each color is a contiguous set of array elements */
	567	/* the number of colors is (size of the array) / (number of input/output
	568	components */
	569	public short[] colorConvert(short[] src, short[] dst) {
	570
	571	if (dst == null) {
	572	dst = new short [(src.length/getNumInComponents())*getNumOutComponents()];
	573	}
	574
	575	LCMSImageLayout srcIL = new LCMSImageLayout(
	576	src, src.length/getNumInComponents(),
	577	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	578	LCMSImageLayout.BYTES_SH(2), getNumInComponents()*2);
	579
	580	LCMSImageLayout dstIL = new LCMSImageLayout(
	581	dst, dst.length/getNumOutComponents(),
	582	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	583	LCMSImageLayout.BYTES_SH(2), getNumOutComponents()*2);
	584
	585	doTransform(srcIL, dstIL);
	586
	587	return dst;
	588	}
	589
	590	public byte[] colorConvert(byte[] src, byte[] dst) {
	591	if (dst == null) {
	592	dst = new byte [(src.length/getNumInComponents())*getNumOutComponents()];
	593	}
	594
	595	LCMSImageLayout srcIL = new LCMSImageLayout(
	596	src, src.length/getNumInComponents(),
	597	LCMSImageLayout.CHANNELS_SH(getNumInComponents()) \|
	598	LCMSImageLayout.BYTES_SH(1), getNumInComponents());
	599
	600	LCMSImageLayout dstIL = new LCMSImageLayout(
	601	dst, dst.length/getNumOutComponents(),
	602	LCMSImageLayout.CHANNELS_SH(getNumOutComponents()) \|
	603	LCMSImageLayout.BYTES_SH(1), getNumOutComponents());
	604
	605	doTransform(srcIL, dstIL);
	606
	607	return dst;
	608	}
	609	}

java/pkg/sun/java2d/cmm/lcms/META-INF/mkfile+6−0

@@ -0,0 +1,6 @@
	1	<../../../../../../../mkconfig
	2
	3	DIRS=\
	4	services\
	5
	6	<$ROOT/mkfiles/mksubdirs

java/pkg/sun/java2d/cmm/lcms/META-INF/services/mkfile+2−0

@@ -0,0 +1,2 @@
	1	<../../../../../../../../mkconfig
	2

java/pkg/sun/java2d/cmm/lcms/META-INF/services/sun.java2d.cmm.PCMM+2−0

@@ -0,0 +1,2 @@
	1	# Little CMS color management module
	2	sun.java2d.cmm.lcms.LCMS

java/pkg/sun/java2d/cmm/lcms/mkfile+14−0

@@ -0,0 +1,14 @@
	1	<../../../../../../mkconfig
	2
	3	DIRS=\
	4	META-INF\
	5
	6	TARG=\
	7	LCMS.dis\
	8	LCMSImageLayout.dis\
	9	LCMSTransform.dis\
	10
	11	DISBIN=$ROOT/java/dis/java/java/sun/java2d/cmm/lcms
	12
	13	<$ROOT/mkfiles/mkjava
	14	<$ROOT/mkfiles/mksubdirs

java/pkg/sun/java2d/cmm/mkfile+17−0

@@ -0,0 +1,17 @@
	1	<../../../../../mkconfig
	2
	3	DIRS=\
	4	lcms\
	5
	6	TARG=\
	7	CMSManager.dis\
	8	ColorTransform.dis\
	9	PCMM.dis\
	10	ProfileActivator.dis\
	11	ProfileDeferralInfo.dis\
	12	ProfileDeferralMgr.dis\
	13
	14	DISBIN=$ROOT/java/dis/java/java/sun/java2d/cmm
	15
	16	<$ROOT/mkfiles/mkjava
	17	<$ROOT/mkfiles/mksubdirs

java/pkg/sun/java2d/loops/Blit$AnyBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/Blit$GeneralMaskBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/Blit$GeneralXorBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/Blit$TraceBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/Blit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/Blit.java+332−0

@@ -0,0 +1,332 @@
	1	/*
	2	* Copyright (c) 1999, 2004, 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.loops;
	27
	28	import java.awt.Composite;
	29	import java.awt.CompositeContext;
	30	import java.awt.RenderingHints;
	31	import java.awt.image.ColorModel;
	32	import java.awt.image.Raster;
	33	import java.awt.image.WritableRaster;
	34	import java.lang.ref.WeakReference;
	35	import sun.java2d.loops.GraphicsPrimitive;
	36	import sun.java2d.SurfaceData;
	37	import sun.java2d.pipe.Region;
	38	import sun.java2d.pipe.SpanIterator;
	39
	40	/**
	41	* Blit
	42	* 1) copies rectangle of pixels from one surface to another
	43	* 2) performs compositing of colors based upon a Composite
	44	* parameter
	45	*
	46	* precise behavior is undefined if the source surface
	47	* and the destination surface are the same surface
	48	* with overlapping regions of pixels
	49	*/
	50
	51	public class Blit extends GraphicsPrimitive
	52	{
	53	public static final String methodSignature = "Blit(...)".toString();
	54
	55	public static final int primTypeID = makePrimTypeID();
	56
	57	private static RenderCache blitcache = new RenderCache(20);
	58
	59	public static Blit locate(SurfaceType srctype,
	60	CompositeType comptype,
	61	SurfaceType dsttype)
	62	{
	63	return (Blit)
	64	GraphicsPrimitiveMgr.locate(primTypeID,
	65	srctype, comptype, dsttype);
	66	}
	67
	68	public static Blit getFromCache(SurfaceType src,
	69	CompositeType comp,
	70	SurfaceType dst)
	71	{
	72	Object o = blitcache.get(src, comp, dst);
	73	if (o != null) {
	74	return (Blit) o;
	75	}
	76
	77	Blit blit = locate(src, comp, dst);
	78	if (blit == null) {
	79	System.out.println("blit loop not found for:");
	80	System.out.println("src: "+src);
	81	System.out.println("comp: "+comp);
	82	System.out.println("dst: "+dst);
	83	} else {
	84	blitcache.put(src, comp, dst, blit);
	85	}
	86	return blit;
	87	}
	88
	89	protected Blit(SurfaceType srctype,
	90	CompositeType comptype,
	91	SurfaceType dsttype)
	92	{
	93	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	94	}
	95
	96	public Blit(long pNativePrim,
	97	SurfaceType srctype,
	98	CompositeType comptype,
	99	SurfaceType dsttype)
	100	{
	101	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	102	}
	103
	104	/**
	105	* All Blit implementors must have this invoker method
	106	*/
	107	public native void Blit(SurfaceData src, SurfaceData dst,
	108	Composite comp, Region clip,
	109	int srcx, int srcy,
	110	int dstx, int dsty,
	111	int width, int height);
	112
	113	static {
	114	GraphicsPrimitiveMgr.registerGeneral(new Blit(null, null, null));
	115	}
	116
	117	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	118	CompositeType comptype,
	119	SurfaceType dsttype)
	120	{
	121	/*
	122	System.out.println("Constructing general blit for:");
	123	System.out.println("src: "+srctype);
	124	System.out.println("comp: "+comptype);
	125	System.out.println("dst: "+dsttype);
	126	*/
	127
	128	if (comptype.isDerivedFrom(CompositeType.Xor)) {
	129	GeneralXorBlit gxb = new GeneralXorBlit(srctype,
	130	comptype,
	131	dsttype);
	132	setupGeneralBinaryOp(gxb);
	133	return gxb;
	134	} else if (comptype.isDerivedFrom(CompositeType.AnyAlpha)) {
	135	return new GeneralMaskBlit(srctype, comptype, dsttype);
	136	} else {
	137	return AnyBlit.instance;
	138	}
	139	}
	140
	141	private static class AnyBlit extends Blit {
	142	public static AnyBlit instance = new AnyBlit();
	143
	144	public AnyBlit() {
	145	super(SurfaceType.Any, CompositeType.Any, SurfaceType.Any);
	146	}
	147
	148	public void Blit(SurfaceData srcData,
	149	SurfaceData dstData,
	150	Composite comp,
	151	Region clip,
	152	int srcx, int srcy,
	153	int dstx, int dsty,
	154	int width, int height)
	155	{
	156	ColorModel srcCM = srcData.getColorModel();
	157	ColorModel dstCM = dstData.getColorModel();
	158	// REMIND: Should get RenderingHints from sg2d
	159	CompositeContext ctx = comp.createContext(srcCM, dstCM,
	160	new RenderingHints(null));
	161	Raster srcRas = srcData.getRaster(srcx, srcy, width, height);
	162	WritableRaster dstRas =
	163	(WritableRaster) dstData.getRaster(dstx, dsty, width, height);
	164
	165	if (clip == null) {
	166	clip = Region.getInstanceXYWH(dstx, dsty, width, height);
	167	}
	168	int span[] = {dstx, dsty, dstx+width, dsty+height};
	169	SpanIterator si = clip.getSpanIterator(span);
	170	srcx -= dstx;
	171	srcy -= dsty;
	172	while (si.nextSpan(span)) {
	173	int w = span[2] - span[0];
	174	int h = span[3] - span[1];
	175	srcRas = srcRas.createChild(srcx + span[0], srcy + span[1],
	176	w, h, 0, 0, null);
	177	dstRas = dstRas.createWritableChild(span[0], span[1],
	178	w, h, 0, 0, null);
	179	ctx.compose(srcRas, dstRas, dstRas);
	180	}
	181	ctx.dispose();
	182	}
	183	}
	184
	185	private static class GeneralMaskBlit extends Blit {
	186	MaskBlit performop;
	187
	188	public GeneralMaskBlit(SurfaceType srctype,
	189	CompositeType comptype,
	190	SurfaceType dsttype)
	191	{
	192	super(srctype, comptype, dsttype);
	193	performop = MaskBlit.locate(srctype, comptype, dsttype);
	194	}
	195
	196	public void Blit(SurfaceData srcData,
	197	SurfaceData dstData,
	198	Composite comp,
	199	Region clip,
	200	int srcx, int srcy,
	201	int dstx, int dsty,
	202	int width, int height)
	203	{
	204	performop.MaskBlit(srcData, dstData, comp, clip,
	205	srcx, srcy, dstx, dsty,
	206	width, height,
	207	null, 0, 0);
	208	}
	209	}
	210
	211	private static class GeneralXorBlit
	212	extends Blit
	213	implements GeneralBinaryOp
	214	{
	215	Blit convertsrc;
	216	Blit convertdst;
	217	Blit performop;
	218	Blit convertresult;
	219
	220	WeakReference srcTmp;
	221	WeakReference dstTmp;
	222
	223	public GeneralXorBlit(SurfaceType srctype,
	224	CompositeType comptype,
	225	SurfaceType dsttype)
	226	{
	227	super(srctype, comptype, dsttype);
	228	}
	229
	230	public void setPrimitives(Blit srcconverter,
	231	Blit dstconverter,
	232	GraphicsPrimitive genericop,
	233	Blit resconverter)
	234	{
	235	this.convertsrc = srcconverter;
	236	this.convertdst = dstconverter;
	237	this.performop = (Blit) genericop;
	238	this.convertresult = resconverter;
	239	}
	240
	241	public synchronized void Blit(SurfaceData srcData,
	242	SurfaceData dstData,
	243	Composite comp,
	244	Region clip,
	245	int srcx, int srcy,
	246	int dstx, int dsty,
	247	int width, int height)
	248	{
	249	SurfaceData src, dst;
	250	Region opclip;
	251	int sx, sy, dx, dy;
	252
	253	if (convertsrc == null) {
	254	src = srcData;
	255	sx = srcx;
	256	sy = srcy;
	257	} else {
	258	SurfaceData cachedSrc = null;
	259	if (srcTmp != null) {
	260	cachedSrc = (SurfaceData) srcTmp.get();
	261	}
	262	src = convertFrom(convertsrc, srcData, srcx, srcy,
	263	width, height, cachedSrc);
	264	sx = 0;
	265	sy = 0;
	266	if (src != cachedSrc) {
	267	srcTmp = new WeakReference(src);
	268	}
	269	}
	270
	271	if (convertdst == null) {
	272	dst = dstData;
	273	dx = dstx;
	274	dy = dsty;
	275	opclip = clip;
	276	} else {
	277	// assert: convertresult != null
	278	SurfaceData cachedDst = null;
	279	if (dstTmp != null) {
	280	cachedDst = (SurfaceData) dstTmp.get();
	281	}
	282	dst = convertFrom(convertdst, dstData, dstx, dsty,
	283	width, height, cachedDst);
	284	dx = 0;
	285	dy = 0;
	286	opclip = null;
	287	if (dst != cachedDst) {
	288	dstTmp = new WeakReference(dst);
	289	}
	290	}
	291
	292	performop.Blit(src, dst, comp, opclip,
	293	sx, sy, dx, dy,
	294	width, height);
	295
	296	if (convertresult != null) {
	297	// assert: convertdst != null
	298	convertTo(convertresult, dst, dstData, clip,
	299	dstx, dsty, width, height);
	300	}
	301	}
	302	}
	303
	304	public GraphicsPrimitive traceWrap() {
	305	return new TraceBlit(this);
	306	}
	307
	308	private static class TraceBlit extends Blit {
	309	Blit target;
	310
	311	public TraceBlit(Blit target) {
	312	super(target.getSourceType(),
	313	target.getCompositeType(),
	314	target.getDestType());
	315	this.target = target;
	316	}
	317
	318	public GraphicsPrimitive traceWrap() {
	319	return this;
	320	}
	321
	322	public void Blit(SurfaceData src, SurfaceData dst,
	323	Composite comp, Region clip,
	324	int srcx, int srcy, int dstx, int dsty,
	325	int width, int height)
	326	{
	327	tracePrimitive(target);
	328	target.Blit(src, dst, comp, clip,
	329	srcx, srcy, dstx, dsty, width, height);
	330	}
	331	}
	332	}

java/pkg/sun/java2d/loops/BlitBg$General.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/BlitBg$TraceBlitBg.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/BlitBg.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/BlitBg.java+217−0

@@ -0,0 +1,217 @@
	1	/*
	2	* Copyright (c) 1999, 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.loops;
	27
	28	import java.awt.Font;
	29	import java.awt.Color;
	30	import java.awt.Composite;
	31	import java.awt.AlphaComposite;
	32	import java.awt.Transparency;
	33	import java.awt.image.ColorModel;
	34	import java.awt.image.WritableRaster;
	35	import java.awt.image.BufferedImage;
	36	import sun.awt.image.BufImgSurfaceData;
	37	import sun.java2d.loops.GraphicsPrimitive;
	38	import sun.java2d.SurfaceData;
	39	import sun.java2d.SunGraphics2D;
	40	import sun.java2d.pipe.Region;
	41
	42	/**
	43	* BlitBg
	44	* 1) copies rectangle of pixels from one surface to another
	45	* 2) performs compositing of colors based upon a Composite
	46	* parameter
	47	* 3) assumes that non-opaque pixels are to be blended with
	48	* the indicated Bg color before compositing with the
	49	* destination
	50	*
	51	* precise behavior is undefined if the source surface
	52	* and the destination surface are the same surface
	53	* with overlapping regions of pixels
	54	*/
	55	public class BlitBg extends GraphicsPrimitive
	56	{
	57	public static final String methodSignature = "BlitBg(...)".toString();
	58
	59	public static final int primTypeID = makePrimTypeID();
	60
	61	private static RenderCache blitcache = new RenderCache(20);
	62
	63	public static BlitBg locate(SurfaceType srctype,
	64	CompositeType comptype,
	65	SurfaceType dsttype)
	66	{
	67	return (BlitBg)
	68	GraphicsPrimitiveMgr.locate(primTypeID,
	69	srctype, comptype, dsttype);
	70	}
	71
	72	public static BlitBg getFromCache(SurfaceType src,
	73	CompositeType comp,
	74	SurfaceType dst)
	75	{
	76	Object o = blitcache.get(src, comp, dst);
	77	if (o != null) {
	78	return (BlitBg) o;
	79	}
	80	BlitBg blit = locate(src, comp, dst);
	81	if (blit == null) {
	82	System.out.println("blitbg loop not found for:");
	83	System.out.println("src: "+src);
	84	System.out.println("comp: "+comp);
	85	System.out.println("dst: "+dst);
	86	} else {
	87	blitcache.put(src, comp, dst, blit);
	88	}
	89	return blit;
	90	}
	91
	92	protected BlitBg(SurfaceType srctype,
	93	CompositeType comptype,
	94	SurfaceType dsttype)
	95	{
	96	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	97	}
	98
	99	public BlitBg(long pNativePrim,
	100	SurfaceType srctype,
	101	CompositeType comptype,
	102	SurfaceType dsttype)
	103	{
	104	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	105	}
	106
	107	/**
	108	* All BlitBg implementors must have this invoker method
	109	*/
	110	public native void BlitBg(SurfaceData src, SurfaceData dst,
	111	Composite comp, Region clip,
	112	int bgColor,
	113	int srcx, int srcy,
	114	int dstx, int dsty,
	115	int width, int height);
	116
	117	static {
	118	GraphicsPrimitiveMgr.registerGeneral(new BlitBg(null, null, null));
	119	}
	120
	121	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	122	CompositeType comptype,
	123	SurfaceType dsttype)
	124	{
	125	/*
	126	System.out.println("Constructing general blitbg for:");
	127	System.out.println("src: "+srctype);
	128	System.out.println("comp: "+comptype);
	129	System.out.println("dst: "+dsttype);
	130	*/
	131	return new General(srctype, comptype, dsttype);
	132	}
	133
	134	private static class General extends BlitBg {
	135	CompositeType compositeType;
	136
	137	public General(SurfaceType srctype,
	138	CompositeType comptype,
	139	SurfaceType dsttype)
	140	{
	141	super(srctype, comptype, dsttype);
	142	compositeType = comptype;
	143	}
	144
	145	@Override
	146	public void BlitBg(SurfaceData srcData,
	147	SurfaceData dstData,
	148	Composite comp,
	149	Region clip,
	150	int bgArgb,
	151	int srcx, int srcy,
	152	int dstx, int dsty,
	153	int width, int height)
	154	{
	155	ColorModel dstModel = dstData.getColorModel();
	156	boolean bgHasAlpha = (bgArgb >>> 24) != 0xff;
	157	if (!dstModel.hasAlpha() && bgHasAlpha) {
	158	dstModel = ColorModel.getRGBdefault();
	159	}
	160	WritableRaster wr =
	161	dstModel.createCompatibleWritableRaster(width, height);
	162	boolean isPremult = dstModel.isAlphaPremultiplied();
	163	BufferedImage bimg =
	164	new BufferedImage(dstModel, wr, isPremult, null);
	165	SurfaceData tmpData = BufImgSurfaceData.createData(bimg);
	166	Color bgColor = new Color(bgArgb, bgHasAlpha);
	167	SunGraphics2D sg2d = new SunGraphics2D(tmpData, bgColor, bgColor,
	168	defaultFont);
	169	FillRect fillop = FillRect.locate(SurfaceType.AnyColor,
	170	CompositeType.SrcNoEa,
	171	tmpData.getSurfaceType());
	172	Blit combineop = Blit.getFromCache(srcData.getSurfaceType(),
	173	CompositeType.SrcOverNoEa,
	174	tmpData.getSurfaceType());
	175	Blit blitop = Blit.getFromCache(tmpData.getSurfaceType(), compositeType,
	176	dstData.getSurfaceType());
	177	fillop.FillRect(sg2d, tmpData, 0, 0, width, height);
	178	combineop.Blit(srcData, tmpData, AlphaComposite.SrcOver, null,
	179	srcx, srcy, 0, 0, width, height);
	180	blitop.Blit(tmpData, dstData, comp, clip,
	181	0, 0, dstx, dsty, width, height);
	182	}
	183
	184	private static Font defaultFont = new Font("Dialog", Font.PLAIN, 12);
	185	}
	186
	187	public GraphicsPrimitive traceWrap() {
	188	return new TraceBlitBg(this);
	189	}
	190
	191	private static class TraceBlitBg extends BlitBg {
	192	BlitBg target;
	193
	194	public TraceBlitBg(BlitBg target) {
	195	super(target.getSourceType(),
	196	target.getCompositeType(),
	197	target.getDestType());
	198	this.target = target;
	199	}
	200
	201	public GraphicsPrimitive traceWrap() {
	202	return this;
	203	}
	204
	205	@Override
	206	public void BlitBg(SurfaceData src, SurfaceData dst,
	207	Composite comp, Region clip,
	208	int bgColor,
	209	int srcx, int srcy, int dstx, int dsty,
	210	int width, int height)
	211	{
	212	tracePrimitive(target);
	213	target.BlitBg(src, dst, comp, clip, bgColor,
	214	srcx, srcy, dstx, dsty, width, height);
	215	}
	216	}
	217	}

java/pkg/sun/java2d/loops/CompositeType.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/CompositeType.java+295−0

@@ -0,0 +1,295 @@
	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.loops;
	27
	28	import java.awt.image.BufferedImage;
	29	import java.awt.AlphaComposite;
	30	import java.util.HashMap;
	31
	32	/**
	33	* A CompositeType object provides a chained description of a type of
	34	* algorithm for color compositing. The object will provide a single
	35	* String constant descriptor which is one way of describing a particular
	36	* compositing algorithm as well as a pointer to another CompositeType
	37	* which describes a more general algorithm for achieving the same result.
	38	* <p>
	39	* A description of a more specific algorithm is considered a "subtype"
	40	* and a description of a more general algorithm is considered a "supertype".
	41	* Thus, the deriveSubType method provides a way to create a new CompositeType
	42	* that is related to but more specific than an existing CompositeType and
	43	* the getSuperType method provides a way to ask a given CompositeType
	44	* for a more general algorithm to achieve the same result.
	45	* <p>
	46	* Note that you cannot construct a brand new root for a chain since
	47	* the constructor is private. Every chain of types must at some point
	48	* derive from the Any node provided here using the deriveSubType()
	49	* method. The presence of this common Any node on every chain
	50	* ensures that all chains end with the DESC_ANY descriptor so that
	51	* a suitable General GraphicsPrimitive object can be obtained for
	52	* the indicated algorithm if all of the more specific searches fail.
	53	*/
	54	public final class CompositeType {
	55
	56	private static int unusedUID = 1;
	57	private static final HashMap<String,Integer> compositeUIDMap =
	58	new HashMap<String,Integer>(100);
	59
	60	/*
	61	* CONSTANTS USED BY ALL PRIMITIVES TO DESCRIBE THE COMPOSITING
	62	* ALGORITHMS THEY CAN PERFORM
	63	*/
	64
	65	/**
	66	* algorithm is a general algorithm that uses a CompositeContext
	67	* to do the rendering.
	68	*/
	69	public static final String DESC_ANY = "Any CompositeContext";
	70
	71	/**
	72	* constant used to describe the Graphics.setXORMode() algorithm
	73	*/
	74	public static final String DESC_XOR = "XOR mode";
	75
	76	/**
	77	* constants used to describe the various AlphaComposite
	78	* algorithms.
	79	*/
	80	public static final String DESC_CLEAR = "Porter-Duff Clear";
	81	public static final String DESC_SRC = "Porter-Duff Src";
	82	public static final String DESC_DST = "Porter-Duff Dst";
	83	public static final String DESC_SRC_OVER = "Porter-Duff Src Over Dst";
	84	public static final String DESC_DST_OVER = "Porter-Duff Dst Over Src";
	85	public static final String DESC_SRC_IN = "Porter-Duff Src In Dst";
	86	public static final String DESC_DST_IN = "Porter-Duff Dst In Src";
	87	public static final String DESC_SRC_OUT = "Porter-Duff Src HeldOutBy Dst";
	88	public static final String DESC_DST_OUT = "Porter-Duff Dst HeldOutBy Src";
	89	public static final String DESC_SRC_ATOP = "Porter-Duff Src Atop Dst";
	90	public static final String DESC_DST_ATOP = "Porter-Duff Dst Atop Src";
	91	public static final String DESC_ALPHA_XOR = "Porter-Duff Xor";
	92
	93	/**
	94	* constants used to describe the two common cases of
	95	* AlphaComposite algorithms that are simpler if there
	96	* is not extraAlpha.
	97	*/
	98	public static final String
	99	DESC_SRC_NO_EA = "Porter-Duff Src, No Extra Alpha";
	100	public static final String
	101	DESC_SRC_OVER_NO_EA = "Porter-Duff SrcOverDst, No Extra Alpha";
	102
	103	/**
	104	* constant used to describe an algorithm that implements all 8 of
	105	* the Porter-Duff rules in one Primitive.
	106	*/
	107	public static final String DESC_ANY_ALPHA = "Any AlphaComposite Rule";
	108
	109	/*
	110	* END OF COMPOSITE ALGORITHM TYPE CONSTANTS
	111	*/
	112
	113	/**
	114	* The root CompositeType object for all chains of algorithm descriptions.
	115	*/
	116	public static final CompositeType
	117	Any = new CompositeType(null, DESC_ANY);
	118
	119	/*
	120	* START OF CompositeeType OBJECTS FOR THE VARIOUS CONSTANTS
	121	*/
	122
	123	public static final CompositeType
	124	General = Any;
	125
	126	public static final CompositeType
	127	AnyAlpha = General.deriveSubType(DESC_ANY_ALPHA);
	128	public static final CompositeType
	129	Xor = General.deriveSubType(DESC_XOR);
	130
	131	public static final CompositeType
	132	Clear = AnyAlpha.deriveSubType(DESC_CLEAR);
	133	public static final CompositeType
	134	Src = AnyAlpha.deriveSubType(DESC_SRC);
	135	public static final CompositeType
	136	Dst = AnyAlpha.deriveSubType(DESC_DST);
	137	public static final CompositeType
	138	SrcOver = AnyAlpha.deriveSubType(DESC_SRC_OVER);
	139	public static final CompositeType
	140	DstOver = AnyAlpha.deriveSubType(DESC_DST_OVER);
	141	public static final CompositeType
	142	SrcIn = AnyAlpha.deriveSubType(DESC_SRC_IN);
	143	public static final CompositeType
	144	DstIn = AnyAlpha.deriveSubType(DESC_DST_IN);
	145	public static final CompositeType
	146	SrcOut = AnyAlpha.deriveSubType(DESC_SRC_OUT);
	147	public static final CompositeType
	148	DstOut = AnyAlpha.deriveSubType(DESC_DST_OUT);
	149	public static final CompositeType
	150	SrcAtop = AnyAlpha.deriveSubType(DESC_SRC_ATOP);
	151	public static final CompositeType
	152	DstAtop = AnyAlpha.deriveSubType(DESC_DST_ATOP);
	153	public static final CompositeType
	154	AlphaXor = AnyAlpha.deriveSubType(DESC_ALPHA_XOR);
	155
	156	public static final CompositeType
	157	SrcNoEa = Src.deriveSubType(DESC_SRC_NO_EA);
	158	public static final CompositeType
	159	SrcOverNoEa = SrcOver.deriveSubType(DESC_SRC_OVER_NO_EA);
	160
	161	/*
	162	* A special CompositeType for the case where we are filling in
	163	* SrcOverNoEa mode with an opaque color. In that case then the
	164	* best loop for us to use would be a SrcNoEa loop, but what if
	165	* there is no such loop? In that case then we would end up
	166	* backing off to a Src loop (which should still be fine) or an
	167	* AnyAlpha loop which would be slower than a SrcOver loop in
	168	* most cases.
	169	* The fix is to use the following chain which looks for loops
	170	* in the following order:
	171	* SrcNoEa, Src, SrcOverNoEa, SrcOver, AnyAlpha
	172	*/
	173	public static final CompositeType
	174	OpaqueSrcOverNoEa = SrcOverNoEa.deriveSubType(DESC_SRC)
	175	.deriveSubType(DESC_SRC_NO_EA);
	176
	177	/*
	178	* END OF CompositeType OBJECTS FOR THE VARIOUS CONSTANTS
	179	*/
	180
	181	/**
	182	* Return a new CompositeType object which uses this object as its
	183	* more general "supertype" descriptor. If no operation can be
	184	* found that implements the algorithm described more exactly
	185	* by desc, then this object will define the more general
	186	* compositing algorithm that can be used instead.
	187	*/
	188	public CompositeType deriveSubType(String desc) {
	189	return new CompositeType(this, desc);
	190	}
	191
	192	/**
	193	* Return a CompositeType object for the specified AlphaComposite
	194	* rule.
	195	*/
	196	public static CompositeType forAlphaComposite(AlphaComposite ac) {
	197	switch (ac.getRule()) {
	198	case AlphaComposite.CLEAR:
	199	return Clear;
	200	case AlphaComposite.SRC:
	201	if (ac.getAlpha() >= 1.0f) {
	202	return SrcNoEa;
	203	} else {
	204	return Src;
	205	}
	206	case AlphaComposite.DST:
	207	return Dst;
	208	case AlphaComposite.SRC_OVER:
	209	if (ac.getAlpha() >= 1.0f) {
	210	return SrcOverNoEa;
	211	} else {
	212	return SrcOver;
	213	}
	214	case AlphaComposite.DST_OVER:
	215	return DstOver;
	216	case AlphaComposite.SRC_IN:
	217	return SrcIn;
	218	case AlphaComposite.DST_IN:
	219	return DstIn;
	220	case AlphaComposite.SRC_OUT:
	221	return SrcOut;
	222	case AlphaComposite.DST_OUT:
	223	return DstOut;
	224	case AlphaComposite.SRC_ATOP:
	225	return SrcAtop;
	226	case AlphaComposite.DST_ATOP:
	227	return DstAtop;
	228	case AlphaComposite.XOR:
	229	return AlphaXor;
	230	default:
	231	throw new InternalError("Unrecognized alpha rule");
	232	}
	233	}
	234
	235	private int uniqueID;
	236	private String desc;
	237	private CompositeType next;
	238
	239	private CompositeType(CompositeType parent, String desc) {
	240	next = parent;
	241	this.desc = desc;
	242	this.uniqueID = makeUniqueID(desc);
	243	}
	244
	245	public synchronized static final int makeUniqueID(String desc) {
	246	Integer i = compositeUIDMap.get(desc);
	247
	248	if (i == null) {
	249	if (unusedUID > 255) {
	250	throw new InternalError("composite type id overflow");
	251	}
	252	i = unusedUID++;
	253	compositeUIDMap.put(desc, i);
	254	}
	255	return i;
	256	}
	257
	258	public int getUniqueID() {
	259	return uniqueID;
	260	}
	261
	262	public String getDescriptor() {
	263	return desc;
	264	}
	265
	266	public CompositeType getSuperType() {
	267	return next;
	268	}
	269
	270	public int hashCode() {
	271	return desc.hashCode();
	272	}
	273
	274	public boolean isDerivedFrom(CompositeType other) {
	275	CompositeType comptype = this;
	276	do {
	277	if (comptype.desc == other.desc) {
	278	return true;
	279	}
	280	comptype = comptype.next;
	281	} while (comptype != null);
	282	return false;
	283	}
	284
	285	public boolean equals(Object o) {
	286	if (o instanceof CompositeType) {
	287	return (((CompositeType) o).uniqueID == this.uniqueID);
	288	}
	289	return false;
	290	}
	291
	292	public String toString() {
	293	return desc;
	294	}
	295	}

java/pkg/sun/java2d/loops/CustomComponent.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/CustomComponent.java+329−0

@@ -0,0 +1,329 @@
	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	/*
	27	* @author Charlton Innovations, Inc.
	28	* @author Jim Graham
	29	*/
	30
	31	package sun.java2d.loops;
	32
	33	import java.awt.Composite;
	34	import java.awt.Rectangle;
	35	import java.awt.image.ColorModel;
	36	import java.awt.image.DataBuffer;
	37	import java.awt.image.Raster;
	38	import java.awt.image.WritableRaster;
	39	import sun.awt.image.IntegerComponentRaster;
	40	import sun.java2d.SurfaceData;
	41	import sun.java2d.pipe.Region;
	42	import sun.java2d.pipe.SpanIterator;
	43
	44	/**
	45	* CustomComponent, collection of GraphicsPrimitive
	46	* Basically, this collection of components performs conversion from
	47	* ANY to ANY via opaque copy
	48	*/
	49	public final class CustomComponent {
	50	public static void register() {
	51	// REMIND: This does not work for all destinations yet since
	52	// the screen SurfaceData objects do not implement getRaster
	53	Class owner = CustomComponent.class;
	54	GraphicsPrimitive[] primitives = {
	55	new GraphicsPrimitiveProxy(owner, "OpaqueCopyAnyToArgb",
	56	Blit.methodSignature,
	57	Blit.primTypeID,
	58	SurfaceType.Any,
	59	CompositeType.SrcNoEa,
	60	SurfaceType.IntArgb),
	61	new GraphicsPrimitiveProxy(owner, "OpaqueCopyArgbToAny",
	62	Blit.methodSignature,
	63	Blit.primTypeID,
	64	SurfaceType.IntArgb,
	65	CompositeType.SrcNoEa,
	66	SurfaceType.Any),
	67	new GraphicsPrimitiveProxy(owner, "XorCopyArgbToAny",
	68	Blit.methodSignature,
	69	Blit.primTypeID,
	70	SurfaceType.IntArgb,
	71	CompositeType.Xor,
	72	SurfaceType.Any),
	73	};
	74	GraphicsPrimitiveMgr.register(primitives);
	75	}
	76
	77	public static Region getRegionOfInterest(SurfaceData src, SurfaceData dst,
	78	Region clip,
	79	int srcx, int srcy,
	80	int dstx, int dsty,
	81	int w, int h)
	82	{
	83	/*
	84	* Intersect all of:
	85	* - operation area (dstx, dsty, w, h)
	86	* - destination bounds
	87	* - (translated) src bounds
	88	* - supplied clip (may be non-rectangular)
	89	* Intersect the rectangular regions first since those are
	90	* simpler operations.
	91	*/
	92	Region ret = Region.getInstanceXYWH(dstx, dsty, w, h);
	93	ret = ret.getIntersection(dst.getBounds());
	94	Rectangle r = src.getBounds();
	95	// srcxy in src space maps to dstxy in dst space
	96	r.translate(dstx - srcx, dsty - srcy);
	97	ret = ret.getIntersection(r);
	98	if (clip != null) {
	99	// Intersect with clip last since it may be non-rectangular
	100	ret = ret.getIntersection(clip);
	101	}
	102	return ret;
	103	}
	104	}
	105
	106	/**
	107	* ANY format to ARGB format Blit
	108	*/
	109	class OpaqueCopyAnyToArgb extends Blit {
	110	OpaqueCopyAnyToArgb() {
	111	super(SurfaceType.Any,
	112	CompositeType.SrcNoEa,
	113	SurfaceType.IntArgb);
	114	}
	115
	116	public void Blit(SurfaceData src, SurfaceData dst,
	117	Composite comp, Region clip,
	118	int srcx, int srcy, int dstx, int dsty, int w, int h)
	119	{
	120	Raster srcRast = src.getRaster(srcx, srcy, w, h);
	121	ColorModel srcCM = src.getColorModel();
	122
	123	Raster dstRast = dst.getRaster(dstx, dsty, w, h);
	124	IntegerComponentRaster icr = (IntegerComponentRaster) dstRast;
	125	int[] dstPix = icr.getDataStorage();
	126
	127	Region roi = CustomComponent.getRegionOfInterest(src, dst, clip,
	128	srcx, srcy,
	129	dstx, dsty, w, h);
	130	SpanIterator si = roi.getSpanIterator();
	131
	132	Object srcPix = null;
	133
	134	int dstScan = icr.getScanlineStride();
	135	// assert(icr.getPixelStride() == 1);
	136	srcx -= dstx;
	137	srcy -= dsty;
	138	int span[] = new int[4];
	139	while (si.nextSpan(span)) {
	140	int rowoff = icr.getDataOffset(0) + span[1] * dstScan + span[0];
	141	for (int y = span[1]; y < span[3]; y++) {
	142	int off = rowoff;
	143	for (int x = span[0]; x < span[2]; x++) {
	144	srcPix = srcRast.getDataElements(x+srcx, y+srcy, srcPix);
	145	dstPix[off++] = srcCM.getRGB(srcPix);
	146	}
	147	rowoff += dstScan;
	148	}
	149	}
	150	// Pixels in the dest were modified directly, we must
	151	// manually notify the raster that it was modified
	152	icr.markDirty();
	153	// REMIND: We need to do something to make sure that dstRast
	154	// is put back to the destination (as in the native Release
	155	// function)
	156	// src.releaseRaster(srcRast); // NOP?
	157	// dst.releaseRaster(dstRast);
	158	}
	159	}
	160
	161	/**
	162	* ARGB format to ANY format Blit
	163	*/
	164	class OpaqueCopyArgbToAny extends Blit {
	165	OpaqueCopyArgbToAny() {
	166	super(SurfaceType.IntArgb,
	167	CompositeType.SrcNoEa,
	168	SurfaceType.Any);
	169	}
	170
	171	public void Blit(SurfaceData src, SurfaceData dst,
	172	Composite comp, Region clip,
	173	int srcx, int srcy, int dstx, int dsty, int w, int h)
	174	{
	175	Raster srcRast = src.getRaster(srcx, srcy, w, h);
	176	IntegerComponentRaster icr = (IntegerComponentRaster) srcRast;
	177	int[] srcPix = icr.getDataStorage();
	178
	179	WritableRaster dstRast =
	180	(WritableRaster) dst.getRaster(dstx, dsty, w, h);
	181	ColorModel dstCM = dst.getColorModel();
	182
	183	Region roi = CustomComponent.getRegionOfInterest(src, dst, clip,
	184	srcx, srcy,
	185	dstx, dsty, w, h);
	186	SpanIterator si = roi.getSpanIterator();
	187
	188	Object dstPix = null;
	189
	190	int srcScan = icr.getScanlineStride();
	191	// assert(icr.getPixelStride() == 1);
	192	srcx -= dstx;
	193	srcy -= dsty;
	194	int span[] = new int[4];
	195	while (si.nextSpan(span)) {
	196	int rowoff = (icr.getDataOffset(0) +
	197	(srcy + span[1]) * srcScan +
	198	(srcx + span[0]));
	199	for (int y = span[1]; y < span[3]; y++) {
	200	int off = rowoff;
	201	for (int x = span[0]; x < span[2]; x++) {
	202	dstPix = dstCM.getDataElements(srcPix[off++], dstPix);
	203	dstRast.setDataElements(x, y, dstPix);
	204	}
	205	rowoff += srcScan;
	206	}
	207	}
	208	// REMIND: We need to do something to make sure that dstRast
	209	// is put back to the destination (as in the native Release
	210	// function)
	211	// src.releaseRaster(srcRast); // NOP?
	212	// dst.releaseRaster(dstRast);
	213	}
	214	}
	215
	216	/**
	217	* ARGB format to ANY format Blit (pixels are XORed together with XOR pixel)
	218	*/
	219	class XorCopyArgbToAny extends Blit {
	220	XorCopyArgbToAny() {
	221	super(SurfaceType.IntArgb,
	222	CompositeType.Xor,
	223	SurfaceType.Any);
	224	}
	225
	226	public void Blit(SurfaceData src, SurfaceData dst,
	227	Composite comp, Region clip,
	228	int srcx, int srcy, int dstx, int dsty, int w, int h)
	229	{
	230	Raster srcRast = src.getRaster(srcx, srcy, w, h);
	231	IntegerComponentRaster icr = (IntegerComponentRaster) srcRast;
	232	int[] srcPix = icr.getDataStorage();
	233
	234	WritableRaster dstRast =
	235	(WritableRaster) dst.getRaster(dstx, dsty, w, h);
	236	ColorModel dstCM = dst.getColorModel();
	237
	238	Region roi = CustomComponent.getRegionOfInterest(src, dst, clip,
	239	srcx, srcy,
	240	dstx, dsty, w, h);
	241	SpanIterator si = roi.getSpanIterator();
	242
	243	int xorrgb = ((XORComposite)comp).getXorColor().getRGB();
	244	Object xorPixel = dstCM.getDataElements(xorrgb, null);
	245
	246	Object srcPixel = null;
	247	Object dstPixel = null;
	248
	249	int srcScan = icr.getScanlineStride();
	250	// assert(icr.getPixelStride() == 1);
	251	srcx -= dstx;
	252	srcy -= dsty;
	253	int span[] = new int[4];
	254	while (si.nextSpan(span)) {
	255	int rowoff = (icr.getDataOffset(0) +
	256	(srcy + span[1]) * srcScan +
	257	(srcx + span[0]));
	258	for (int y = span[1]; y < span[3]; y++) {
	259	int off = rowoff;
	260	for (int x = span[0]; x < span[2]; x++) {
	261	// REMIND: alpha bits of the destination pixel are
	262	// currently altered by the XOR operation, but
	263	// should be left untouched
	264	srcPixel = dstCM.getDataElements(srcPix[off++], srcPixel);
	265	dstPixel = dstRast.getDataElements(x, y, dstPixel);
	266
	267	switch (dstCM.getTransferType()) {
	268	case DataBuffer.TYPE_BYTE:
	269	byte[] bytesrcarr = (byte[]) srcPixel;
	270	byte[] bytedstarr = (byte[]) dstPixel;
	271	byte[] bytexorarr = (byte[]) xorPixel;
	272	for (int i = 0; i < bytedstarr.length; i++) {
	273	bytedstarr[i] ^= bytesrcarr[i] ^ bytexorarr[i];
	274	}
	275	break;
	276	case DataBuffer.TYPE_SHORT:
	277	case DataBuffer.TYPE_USHORT:
	278	short[] shortsrcarr = (short[]) srcPixel;
	279	short[] shortdstarr = (short[]) dstPixel;
	280	short[] shortxorarr = (short[]) xorPixel;
	281	for (int i = 0; i < shortdstarr.length; i++) {
	282	shortdstarr[i] ^= shortsrcarr[i] ^ shortxorarr[i];
	283	}
	284	break;
	285	case DataBuffer.TYPE_INT:
	286	int[] intsrcarr = (int[]) srcPixel;
	287	int[] intdstarr = (int[]) dstPixel;
	288	int[] intxorarr = (int[]) xorPixel;
	289	for (int i = 0; i < intdstarr.length; i++) {
	290	intdstarr[i] ^= intsrcarr[i] ^ intxorarr[i];
	291	}
	292	break;
	293	case DataBuffer.TYPE_FLOAT:
	294	float[] floatsrcarr = (float[]) srcPixel;
	295	float[] floatdstarr = (float[]) dstPixel;
	296	float[] floatxorarr = (float[]) xorPixel;
	297	for (int i = 0; i < floatdstarr.length; i++) {
	298	int v = (Float.floatToIntBits(floatdstarr[i]) ^
	299	Float.floatToIntBits(floatsrcarr[i]) ^
	300	Float.floatToIntBits(floatxorarr[i]));
	301	floatdstarr[i] = Float.intBitsToFloat(v);
	302	}
	303	break;
	304	case DataBuffer.TYPE_DOUBLE:
	305	double[] doublesrcarr = (double[]) srcPixel;
	306	double[] doubledstarr = (double[]) dstPixel;
	307	double[] doublexorarr = (double[]) xorPixel;
	308	for (int i = 0; i < doubledstarr.length; i++) {
	309	long v = (Double.doubleToLongBits(doubledstarr[i]) ^
	310	Double.doubleToLongBits(doublesrcarr[i]) ^
	311	Double.doubleToLongBits(doublexorarr[i]));
	312	doubledstarr[i] = Double.longBitsToDouble(v);
	313	}
	314	break;
	315	default:
	316	throw new InternalError("Unsupported XOR pixel type");
	317	}
	318	dstRast.setDataElements(x, y, dstPixel);
	319	}
	320	rowoff += srcScan;
	321	}
	322	}
	323	// REMIND: We need to do something to make sure that dstRast
	324	// is put back to the destination (as in the native Release
	325	// function)
	326	// src.releaseRaster(srcRast); // NOP?
	327	// dst.releaseRaster(dstRast);
	328	}
	329	}

java/pkg/sun/java2d/loops/DrawGlyphList$General.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphList$TraceDrawGlyphList.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphList.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphList.java+161−0

@@ -0,0 +1,161 @@
	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.loops;
	27
	28	import sun.java2d.loops.GraphicsPrimitive;
	29	import sun.java2d.pipe.Region;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.java2d.SurfaceData;
	32	import sun.font.GlyphList;
	33
	34	/**
	35	* DrawGlyphList - loops for SolidTextRenderer pipe.
	36	* 1) draw solid color text onto destination surface
	37	* 2) must accept output area [x, y, dx, dy]
	38	* from within the surface description data for clip rect
	39	*/
	40	public class DrawGlyphList extends GraphicsPrimitive {
	41
	42	public final static String methodSignature = "DrawGlyphList(...)".toString();
	43
	44	public final static int primTypeID = makePrimTypeID();
	45
	46	public static DrawGlyphList locate(SurfaceType srctype,
	47	CompositeType comptype,
	48	SurfaceType dsttype)
	49	{
	50	return (DrawGlyphList)
	51	GraphicsPrimitiveMgr.locate(primTypeID,
	52	srctype, comptype, dsttype);
	53	}
	54
	55	protected DrawGlyphList(SurfaceType srctype,
	56	CompositeType comptype,
	57	SurfaceType dsttype)
	58	{
	59	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	60	}
	61
	62	public DrawGlyphList(long pNativePrim,
	63	SurfaceType srctype,
	64	CompositeType comptype,
	65	SurfaceType dsttype)
	66	{
	67	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	68	}
	69
	70
	71	public native void DrawGlyphList(SunGraphics2D sg2d, SurfaceData dest,
	72	GlyphList srcData);
	73
	74	// This instance is used only for lookup.
	75	static {
	76	GraphicsPrimitiveMgr.registerGeneral(
	77	new DrawGlyphList(null, null, null));
	78	}
	79
	80	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	81	CompositeType comptype,
	82	SurfaceType dsttype) {
	83	return new General(srctype, comptype, dsttype);
	84	}
	85
	86	private static class General extends DrawGlyphList {
	87	MaskFill maskop;
	88
	89	public General(SurfaceType srctype,
	90	CompositeType comptype,
	91	SurfaceType dsttype)
	92	{
	93	super(srctype, comptype, dsttype);
	94	maskop = MaskFill.locate(srctype, comptype, dsttype);
	95	}
	96
	97	public void DrawGlyphList(SunGraphics2D sg2d, SurfaceData dest,
	98	GlyphList gl) {
	99
	100	int strbounds[] = gl.getBounds(); // Don't delete, bug 4895493
	101	int num = gl.getNumGlyphs();
	102	Region clip = sg2d.getCompClip();
	103	int cx1 = clip.getLoX();
	104	int cy1 = clip.getLoY();
	105	int cx2 = clip.getHiX();
	106	int cy2 = clip.getHiY();
	107	for (int i = 0; i < num; i++) {
	108	gl.setGlyphIndex(i);
	109	int metrics[] = gl.getMetrics();
	110	int gx1 = metrics[0];
	111	int gy1 = metrics[1];
	112	int w = metrics[2];
	113	int gx2 = gx1 + w;
	114	int gy2 = gy1 + metrics[3];
	115	int off = 0;
	116	if (gx1 < cx1) {
	117	off = cx1 - gx1;
	118	gx1 = cx1;
	119	}
	120	if (gy1 < cy1) {
	121	off += (cy1 - gy1) * w;
	122	gy1 = cy1;
	123	}
	124	if (gx2 > cx2) gx2 = cx2;
	125	if (gy2 > cy2) gy2 = cy2;
	126	if (gx2 > gx1 && gy2 > gy1) {
	127	byte alpha[] = gl.getGrayBits();
	128	maskop.MaskFill(sg2d, dest, sg2d.composite,
	129	gx1, gy1, gx2 - gx1, gy2 - gy1,
	130	alpha, off, w);
	131	}
	132	}
	133	}
	134	}
	135
	136	public GraphicsPrimitive traceWrap() {
	137	return new TraceDrawGlyphList(this);
	138	}
	139
	140	private static class TraceDrawGlyphList extends DrawGlyphList {
	141	DrawGlyphList target;
	142
	143	public TraceDrawGlyphList(DrawGlyphList target) {
	144	super(target.getSourceType(),
	145	target.getCompositeType(),
	146	target.getDestType());
	147	this.target = target;
	148	}
	149
	150	public GraphicsPrimitive traceWrap() {
	151	return this;
	152	}
	153
	154	public void DrawGlyphList(SunGraphics2D sg2d, SurfaceData dest,
	155	GlyphList glyphs)
	156	{
	157	tracePrimitive(target);
	158	target.DrawGlyphList(sg2d, dest, glyphs);
	159	}
	160	}
	161	}

java/pkg/sun/java2d/loops/DrawGlyphListAA$General.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphListAA$TraceDrawGlyphListAA.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphListAA.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphListAA.java+159−0

@@ -0,0 +1,159 @@
	1	/*
	2	* Copyright (c) 2000, 2004, 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.loops;
	27
	28	import sun.java2d.loops.GraphicsPrimitive;
	29	import sun.java2d.pipe.Region;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.java2d.SurfaceData;
	32	import sun.font.GlyphList;
	33
	34	/**
	35	* DrawGlyphListAA - loops for AATextRenderer pipe
	36	* 1) draw anti-aliased text onto destination surface
	37	* 2) must accept output area [x, y, dx, dy]
	38	* from within the surface description data for clip rect
	39	*/
	40	public class DrawGlyphListAA extends GraphicsPrimitive {
	41
	42	public final static String methodSignature = "DrawGlyphListAA(...)".toString();
	43
	44	public final static int primTypeID = makePrimTypeID();
	45
	46	public static DrawGlyphListAA locate(SurfaceType srctype,
	47	CompositeType comptype,
	48	SurfaceType dsttype)
	49	{
	50	return (DrawGlyphListAA)
	51	GraphicsPrimitiveMgr.locate(primTypeID,
	52	srctype, comptype, dsttype);
	53	}
	54
	55	protected DrawGlyphListAA(SurfaceType srctype,
	56	CompositeType comptype,
	57	SurfaceType dsttype)
	58	{
	59	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	60	}
	61
	62	public DrawGlyphListAA(long pNativePrim,
	63	SurfaceType srctype,
	64	CompositeType comptype,
	65	SurfaceType dsttype)
	66	{
	67	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	68	}
	69
	70	public native void DrawGlyphListAA(SunGraphics2D sg2d, SurfaceData dest,
	71	GlyphList srcData);
	72
	73	static {
	74	GraphicsPrimitiveMgr.registerGeneral(
	75	new DrawGlyphListAA(null, null, null));
	76	}
	77
	78	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	79	CompositeType comptype,
	80	SurfaceType dsttype) {
	81	return new General(srctype, comptype, dsttype);
	82	}
	83
	84	public static class General extends DrawGlyphListAA {
	85	MaskFill maskop;
	86
	87	public General(SurfaceType srctype,
	88	CompositeType comptype,
	89	SurfaceType dsttype)
	90	{
	91	super(srctype, comptype, dsttype);
	92	maskop = MaskFill.locate(srctype, comptype, dsttype);
	93	}
	94
	95	public void DrawGlyphListAA(SunGraphics2D sg2d, SurfaceData dest,
	96	GlyphList gl)
	97	{
	98	gl.getBounds(); // Don't delete, bug 4895493
	99	int num = gl.getNumGlyphs();
	100	Region clip = sg2d.getCompClip();
	101	int cx1 = clip.getLoX();
	102	int cy1 = clip.getLoY();
	103	int cx2 = clip.getHiX();
	104	int cy2 = clip.getHiY();
	105	for (int i = 0; i < num; i++) {
	106	gl.setGlyphIndex(i);
	107	int metrics[] = gl.getMetrics();
	108	int gx1 = metrics[0];
	109	int gy1 = metrics[1];
	110	int w = metrics[2];
	111	int gx2 = gx1 + w;
	112	int gy2 = gy1 + metrics[3];
	113	int off = 0;
	114	if (gx1 < cx1) {
	115	off = cx1 - gx1;
	116	gx1 = cx1;
	117	}
	118	if (gy1 < cy1) {
	119	off += (cy1 - gy1) * w;
	120	gy1 = cy1;
	121	}
	122	if (gx2 > cx2) gx2 = cx2;
	123	if (gy2 > cy2) gy2 = cy2;
	124	if (gx2 > gx1 && gy2 > gy1) {
	125	byte alpha[] = gl.getGrayBits();
	126	maskop.MaskFill(sg2d, dest, sg2d.composite,
	127	gx1, gy1, gx2 - gx1, gy2 - gy1,
	128	alpha, off, w);
	129	}
	130	}
	131	}
	132	}
	133
	134	public GraphicsPrimitive traceWrap() {
	135	return new TraceDrawGlyphListAA(this);
	136	}
	137
	138	private static class TraceDrawGlyphListAA extends DrawGlyphListAA {
	139	DrawGlyphListAA target;
	140
	141	public TraceDrawGlyphListAA(DrawGlyphListAA target) {
	142	super(target.getSourceType(),
	143	target.getCompositeType(),
	144	target.getDestType());
	145	this.target = target;
	146	}
	147
	148	public GraphicsPrimitive traceWrap() {
	149	return this;
	150	}
	151
	152	public void DrawGlyphListAA(SunGraphics2D sg2d, SurfaceData dest,
	153	GlyphList glyphs)
	154	{
	155	tracePrimitive(target);
	156	target.DrawGlyphListAA(sg2d, dest, glyphs);
	157	}
	158	}
	159	}

java/pkg/sun/java2d/loops/DrawGlyphListLCD$TraceDrawGlyphListLCD.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphListLCD.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawGlyphListLCD.java+117−0

@@ -0,0 +1,117 @@
	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.loops;
	27
	28	import sun.java2d.loops.GraphicsPrimitive;
	29	import sun.java2d.pipe.Region;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.java2d.SurfaceData;
	32	import sun.font.GlyphList;
	33
	34	/**
	35	* DrawGlyphListLCD- loops for LCDTextRenderer pipe
	36	* 1) draw LCD anti-aliased text onto destination surface
	37	* 2) must accept output area [x, y, dx, dy]
	38	* from within the surface description data for clip rect
	39	*/
	40	public class DrawGlyphListLCD extends GraphicsPrimitive {
	41
	42	public final static String
	43	methodSignature = "DrawGlyphListLCD(...)".toString();
	44
	45	public final static int primTypeID = makePrimTypeID();
	46
	47	public static DrawGlyphListLCD locate(SurfaceType srctype,
	48	CompositeType comptype,
	49	SurfaceType dsttype)
	50	{
	51	return (DrawGlyphListLCD)
	52	GraphicsPrimitiveMgr.locate(primTypeID,
	53	srctype, comptype, dsttype);
	54	}
	55
	56	protected DrawGlyphListLCD(SurfaceType srctype,
	57	CompositeType comptype,
	58	SurfaceType dsttype)
	59	{
	60	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	61	}
	62
	63	public DrawGlyphListLCD(long pNativePrim,
	64	SurfaceType srctype,
	65	CompositeType comptype,
	66	SurfaceType dsttype)
	67	{
	68	super(pNativePrim, methodSignature, primTypeID,
	69	srctype, comptype, dsttype);
	70	}
	71
	72	public native void DrawGlyphListLCD(SunGraphics2D sg2d, SurfaceData dest,
	73	GlyphList srcData);
	74
	75	static {
	76	GraphicsPrimitiveMgr.registerGeneral(
	77	new DrawGlyphListLCD(null, null, null));
	78	}
	79
	80	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	81	CompositeType comptype,
	82	SurfaceType dsttype) {
	83	/* Do not return a General loop. SunGraphics2D determines whether
	84	* to use LCD or standard AA text based on whether there is an
	85	* installed loop.
	86	* This can be uncommented once there is a General loop which can
	87	* handle one byte per colour component masks properly.
	88	*/
	89	return null;
	90	}
	91
	92	public GraphicsPrimitive traceWrap() {
	93	return new TraceDrawGlyphListLCD(this);
	94	}
	95
	96	private static class TraceDrawGlyphListLCD extends DrawGlyphListLCD {
	97	DrawGlyphListLCD target;
	98
	99	public TraceDrawGlyphListLCD(DrawGlyphListLCD target) {
	100	super(target.getSourceType(),
	101	target.getCompositeType(),
	102	target.getDestType());
	103	this.target = target;
	104	}
	105
	106	public GraphicsPrimitive traceWrap() {
	107	return this;
	108	}
	109
	110	public void DrawGlyphListLCD(SunGraphics2D sg2d, SurfaceData dest,
	111	GlyphList glyphs)
	112	{
	113	tracePrimitive(target);
	114	target.DrawGlyphListLCD(sg2d, dest, glyphs);
	115	}
	116	}
	117	}

java/pkg/sun/java2d/loops/DrawLine$TraceDrawLine.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawLine.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawLine.java+114−0

@@ -0,0 +1,114 @@
	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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import java.awt.Color;
	34	import java.awt.image.ColorModel;
	35	import java.awt.image.Raster;
	36	import sun.java2d.SunGraphics2D;
	37	import sun.java2d.SurfaceData;
	38
	39	/**
	40	* DrawLine
	41	* 1) draw solid color single width line onto destination surface
	42	* 2) must accept output area [x, y, dx, dy]
	43	* from within the surface description data for clip rect
	44	*/
	45	public class DrawLine extends GraphicsPrimitive
	46	{
	47	public final static String methodSignature = "DrawLine(...)".toString();
	48
	49	public final static int primTypeID = makePrimTypeID();
	50
	51	public static DrawLine locate(SurfaceType srctype,
	52	CompositeType comptype,
	53	SurfaceType dsttype)
	54	{
	55	return (DrawLine) GraphicsPrimitiveMgr.locate(primTypeID,
	56	srctype, comptype, dsttype);
	57	}
	58
	59	protected DrawLine(SurfaceType srctype,
	60	CompositeType comptype,
	61	SurfaceType dsttype)
	62	{
	63	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	64	}
	65
	66	public DrawLine(long pNativePrim,
	67	SurfaceType srctype,
	68	CompositeType comptype,
	69	SurfaceType dsttype)
	70	{
	71	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	72	}
	73
	74	/**
	75	* All DrawLine implementors must have this invoker method
	76	*/
	77	public native void DrawLine(SunGraphics2D sg2d, SurfaceData dest,
	78	int x1, int y1, int x2, int y2);
	79
	80	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	81	CompositeType comptype,
	82	SurfaceType dsttype)
	83	{
	84	// REMIND: use FillSpans or converter object?
	85	throw new InternalError("DrawLine not implemented for "+
	86	srctype+" with "+comptype);
	87	}
	88
	89	public GraphicsPrimitive traceWrap() {
	90	return new TraceDrawLine(this);
	91	}
	92
	93	private static class TraceDrawLine extends DrawLine {
	94	DrawLine target;
	95
	96	public TraceDrawLine(DrawLine target) {
	97	super(target.getSourceType(),
	98	target.getCompositeType(),
	99	target.getDestType());
	100	this.target = target;
	101	}
	102
	103	public GraphicsPrimitive traceWrap() {
	104	return this;
	105	}
	106
	107	public void DrawLine(SunGraphics2D sg2d, SurfaceData dest,
	108	int x1, int y1, int x2, int y2)
	109	{
	110	tracePrimitive(target);
	111	target.DrawLine(sg2d, dest, x1, y1, x2, y2);
	112	}
	113	}
	114	}

java/pkg/sun/java2d/loops/DrawParallelogram$TraceDrawParallelogram.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawParallelogram.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawParallelogram.java+123−0

@@ -0,0 +1,123 @@
	1	/*
	2	* Copyright (c) 2008, 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	/*
	27	* @author Jim Graham
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import sun.java2d.SunGraphics2D;
	34	import sun.java2d.SurfaceData;
	35
	36	/**
	37	* DrawParallelogram
	38	* 1) fill the area between the 4 edges of an outer parallelogram
	39	* (as specified by an origin and 2 delta vectors)
	40	* but also outside the 4 edges of an inner parallelogram
	41	* (as specified by proportional amounts of the outer delta vectors)
	42	*/
	43	public class DrawParallelogram extends GraphicsPrimitive
	44	{
	45	public final static String methodSignature =
	46	"DrawParallelogram(...)".toString();
	47
	48	public final static int primTypeID = makePrimTypeID();
	49
	50	public static DrawParallelogram locate(SurfaceType srctype,
	51	CompositeType comptype,
	52	SurfaceType dsttype)
	53	{
	54	return (DrawParallelogram)
	55	GraphicsPrimitiveMgr.locate(primTypeID,
	56	srctype, comptype, dsttype);
	57	}
	58
	59	protected DrawParallelogram(SurfaceType srctype,
	60	CompositeType comptype,
	61	SurfaceType dsttype)
	62	{
	63	super(methodSignature, primTypeID,
	64	srctype, comptype, dsttype);
	65	}
	66
	67	public DrawParallelogram(long pNativePrim,
	68	SurfaceType srctype,
	69	CompositeType comptype,
	70	SurfaceType dsttype)
	71	{
	72	super(pNativePrim, methodSignature, primTypeID,
	73	srctype, comptype, dsttype);
	74	}
	75
	76	/**
	77	* All DrawParallelogram implementors must have this invoker method
	78	*/
	79	public native void DrawParallelogram(SunGraphics2D sg, SurfaceData dest,
	80	double x, double y,
	81	double dx1, double dy1,
	82	double dx2, double dy2,
	83	double lw1, double lw2);
	84
	85	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	86	CompositeType comptype,
	87	SurfaceType dsttype)
	88	{
	89	// REMIND: iterate with a FillRect primitive?
	90	throw new InternalError("DrawParallelogram not implemented for "+
	91	srctype+" with "+comptype);
	92	}
	93
	94	public GraphicsPrimitive traceWrap() {
	95	return new TraceDrawParallelogram(this);
	96	}
	97
	98	private static class TraceDrawParallelogram extends DrawParallelogram {
	99	DrawParallelogram target;
	100
	101	public TraceDrawParallelogram(DrawParallelogram target) {
	102	super(target.getSourceType(),
	103	target.getCompositeType(),
	104	target.getDestType());
	105	this.target = target;
	106	}
	107
	108	public GraphicsPrimitive traceWrap() {
	109	return this;
	110	}
	111
	112	public void DrawParallelogram(SunGraphics2D sg2d, SurfaceData dest,
	113	double x, double y,
	114	double dx1, double dy1,
	115	double dx2, double dy2,
	116	double lw1, double lw2)
	117	{
	118	tracePrimitive(target);
	119	target.DrawParallelogram(sg2d, dest,
	120	x, y, dx1, dy1, dx2, dy2, lw1, lw2);
	121	}
	122	}
	123	}

java/pkg/sun/java2d/loops/DrawPath$TraceDrawPath.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawPath.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawPath.java+114−0

@@ -0,0 +1,114 @@
	1	/*
	2	* Copyright (c) 2005, 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.loops;
	27
	28	import sun.java2d.loops.GraphicsPrimitive;
	29	import sun.java2d.SunGraphics2D;
	30	import sun.java2d.SurfaceData;
	31	import java.awt.geom.Path2D;
	32
	33	/**
	34	* DrawPath
	35	* 1. draw single-width line path onto destination surface
	36	* 2. must accept output area [x, y, dx, dy]
	37	* from within the surface description data for clip rect
	38	*/
	39	public class DrawPath extends GraphicsPrimitive {
	40
	41	public final static String methodSignature =
	42	"DrawPath(...)".toString();
	43
	44	public final static int primTypeID = makePrimTypeID();
	45
	46	public static DrawPath locate(SurfaceType srctype,
	47	CompositeType comptype,
	48	SurfaceType dsttype)
	49	{
	50	return (DrawPath)
	51	GraphicsPrimitiveMgr.locate(primTypeID,
	52	srctype, comptype, dsttype);
	53	}
	54
	55	protected DrawPath(SurfaceType srctype,
	56	CompositeType comptype,
	57	SurfaceType dsttype)
	58	{
	59	super(methodSignature, primTypeID,
	60	srctype, comptype, dsttype);
	61	}
	62
	63	public DrawPath(long pNativePrim,
	64	SurfaceType srctype,
	65	CompositeType comptype,
	66	SurfaceType dsttype)
	67	{
	68	super(pNativePrim, methodSignature, primTypeID,
	69	srctype, comptype, dsttype);
	70	}
	71
	72
	73	/**
	74	* All DrawPath implementors must have this invoker method
	75	*/
	76	public native void DrawPath(SunGraphics2D sg2d, SurfaceData sData,
	77	int transX, int transY,
	78	Path2D.Float p2df);
	79
	80	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	81	CompositeType comptype,
	82	SurfaceType dsttype)
	83	{
	84	throw new InternalError("DrawPath not implemented for "+
	85	srctype+" with "+comptype);
	86	}
	87
	88	public GraphicsPrimitive traceWrap() {
	89	return new TraceDrawPath(this);
	90	}
	91
	92	private static class TraceDrawPath extends DrawPath {
	93	DrawPath target;
	94
	95	public TraceDrawPath(DrawPath target) {
	96	super(target.getSourceType(),
	97	target.getCompositeType(),
	98	target.getDestType());
	99	this.target = target;
	100	}
	101
	102	public GraphicsPrimitive traceWrap() {
	103	return this;
	104	}
	105
	106	public void DrawPath(SunGraphics2D sg2d, SurfaceData sData,
	107	int transX, int transY,
	108	Path2D.Float p2df)
	109	{
	110	tracePrimitive(target);
	111	target.DrawPath(sg2d, sData, transX, transY, p2df);
	112	}
	113	}
	114	}

java/pkg/sun/java2d/loops/DrawPolygons$TraceDrawPolygons.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawPolygons.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawPolygons.java+120−0

@@ -0,0 +1,120 @@
	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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import sun.java2d.SunGraphics2D;
	34	import sun.java2d.SurfaceData;
	35
	36	/**
	37	* DrawPolygons
	38	* 1) draw single-width line polygons onto destination surface
	39	* 2) must accept output area [x, y, dx, dy]
	40	* from within the surface description data for clip rect
	41	*/
	42	public class DrawPolygons extends GraphicsPrimitive
	43	{
	44	public final static String methodSignature = "DrawPolygons(...)".toString();
	45
	46	public final static int primTypeID = makePrimTypeID();
	47
	48	public static DrawPolygons locate(SurfaceType srctype,
	49	CompositeType comptype,
	50	SurfaceType dsttype)
	51	{
	52	return (DrawPolygons)
	53	GraphicsPrimitiveMgr.locate(primTypeID,
	54	srctype, comptype, dsttype);
	55	}
	56
	57	protected DrawPolygons(SurfaceType srctype,
	58	CompositeType comptype,
	59	SurfaceType dsttype)
	60	{
	61	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	62	}
	63
	64	public DrawPolygons(long pNativePrim,
	65	SurfaceType srctype,
	66	CompositeType comptype,
	67	SurfaceType dsttype)
	68	{
	69	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	70	}
	71
	72	/**
	73	* All DrawPolygon implementors must have this invoker method
	74	*/
	75	public native void DrawPolygons(SunGraphics2D sg2d, SurfaceData sData,
	76	int xPoints[], int yPoints[],
	77	int nPoints[], int numPolys,
	78	int transX, int transY,
	79	boolean close);
	80
	81	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	82	CompositeType comptype,
	83	SurfaceType dsttype)
	84	{
	85	// REMIND: use FillSpans or converter object?
	86	throw new InternalError("DrawPolygons not implemented for "+
	87	srctype+" with "+comptype);
	88	}
	89
	90	public GraphicsPrimitive traceWrap() {
	91	return new TraceDrawPolygons(this);
	92	}
	93
	94	private static class TraceDrawPolygons extends DrawPolygons {
	95	DrawPolygons target;
	96
	97	public TraceDrawPolygons(DrawPolygons target) {
	98	super(target.getSourceType(),
	99	target.getCompositeType(),
	100	target.getDestType());
	101	this.target = target;
	102	}
	103
	104	public GraphicsPrimitive traceWrap() {
	105	return this;
	106	}
	107
	108	public void DrawPolygons(SunGraphics2D sg2d, SurfaceData sData,
	109	int xPoints[], int yPoints[],
	110	int nPoints[], int numPolys,
	111	int transX, int transY,
	112	boolean close)
	113	{
	114	tracePrimitive(target);
	115	target.DrawPolygons(sg2d, sData,
	116	xPoints, yPoints, nPoints, numPolys,
	117	transX, transY, close);
	118	}
	119	}
	120	}

java/pkg/sun/java2d/loops/DrawRect$TraceDrawRect.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawRect.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/DrawRect.java+115−0

@@ -0,0 +1,115 @@
	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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import java.awt.Color;
	34	import java.awt.image.ColorModel;
	35	import java.awt.image.Raster;
	36	import sun.java2d.SunGraphics2D;
	37	import sun.java2d.SurfaceData;
	38
	39	/**
	40	* DrawRect
	41	* 1) draw single-width line rectangle onto destination surface
	42	* 2) must accept output area [x, y, dx, dy]
	43	* from within the surface description data for clip rect
	44	*/
	45	public class DrawRect extends GraphicsPrimitive
	46	{
	47	public final static String methodSignature = "DrawRect(...)".toString();
	48
	49	public final static int primTypeID = makePrimTypeID();
	50
	51	public static DrawRect locate(SurfaceType srctype,
	52	CompositeType comptype,
	53	SurfaceType dsttype)
	54	{
	55	return (DrawRect)
	56	GraphicsPrimitiveMgr.locate(primTypeID,
	57	srctype, comptype, dsttype);
	58	}
	59
	60	protected DrawRect(SurfaceType srctype,
	61	CompositeType comptype,
	62	SurfaceType dsttype)
	63	{
	64	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	65	}
	66
	67	public DrawRect(long pNativePrim,
	68	SurfaceType srctype,
	69	CompositeType comptype,
	70	SurfaceType dsttype)
	71	{
	72	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	73	}
	74
	75	/**
	76	* All DrawRect implementors must have this invoker method
	77	*/
	78	public native void DrawRect(SunGraphics2D sg2d, SurfaceData dest,
	79	int x1, int y1, int w, int h);
	80
	81	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	82	CompositeType comptype,
	83	SurfaceType dsttype)
	84	{
	85	// REMIND: use FillSpans or converter object?
	86	throw new InternalError("DrawRect not implemented for "+
	87	srctype+" with "+comptype);
	88	}
	89
	90	public GraphicsPrimitive traceWrap() {
	91	return new TraceDrawRect(this);
	92	}
	93
	94	private static class TraceDrawRect extends DrawRect {
	95	DrawRect target;
	96
	97	public TraceDrawRect(DrawRect target) {
	98	super(target.getSourceType(),
	99	target.getCompositeType(),
	100	target.getDestType());
	101	this.target = target;
	102	}
	103
	104	public GraphicsPrimitive traceWrap() {
	105	return this;
	106	}
	107
	108	public void DrawRect(SunGraphics2D sg2d, SurfaceData dest,
	109	int x1, int y1, int w, int h)
	110	{
	111	tracePrimitive(target);
	112	target.DrawRect(sg2d, dest, x1, y1, w, h);
	113	}
	114	}
	115	}

java/pkg/sun/java2d/loops/FillParallelogram$TraceFillParallelogram.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillParallelogram.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillParallelogram.java+118−0

@@ -0,0 +1,118 @@
	1	/*
	2	* Copyright (c) 2008, 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	/*
	27	* @author Jim Graham
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import sun.java2d.SunGraphics2D;
	34	import sun.java2d.SurfaceData;
	35
	36	/**
	37	* FillParallelogram
	38	* 1) fill the area between the 4 edges of a parallelogram
	39	* (as specified by an origin and 2 delta vectors)
	40	*/
	41	public class FillParallelogram extends GraphicsPrimitive
	42	{
	43	public final static String methodSignature =
	44	"FillParallelogram(...)".toString();
	45
	46	public final static int primTypeID = makePrimTypeID();
	47
	48	public static FillParallelogram locate(SurfaceType srctype,
	49	CompositeType comptype,
	50	SurfaceType dsttype)
	51	{
	52	return (FillParallelogram)
	53	GraphicsPrimitiveMgr.locate(primTypeID,
	54	srctype, comptype, dsttype);
	55	}
	56
	57	protected FillParallelogram(SurfaceType srctype,
	58	CompositeType comptype,
	59	SurfaceType dsttype)
	60	{
	61	super(methodSignature, primTypeID,
	62	srctype, comptype, dsttype);
	63	}
	64
	65	public FillParallelogram(long pNativePrim,
	66	SurfaceType srctype,
	67	CompositeType comptype,
	68	SurfaceType dsttype)
	69	{
	70	super(pNativePrim, methodSignature, primTypeID,
	71	srctype, comptype, dsttype);
	72	}
	73
	74	/**
	75	* All FillParallelogram implementors must have this invoker method
	76	*/
	77	public native void FillParallelogram(SunGraphics2D sg2d, SurfaceData dest,
	78	double x0, double y0,
	79	double dx1, double dy1,
	80	double dx2, double dy2);
	81
	82	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	83	CompositeType comptype,
	84	SurfaceType dsttype)
	85	{
	86	// REMIND: iterate with a FillRect primitive?
	87	throw new InternalError("FillParallelogram not implemented for "+
	88	srctype+" with "+comptype);
	89	}
	90
	91	public GraphicsPrimitive traceWrap() {
	92	return new TraceFillParallelogram(this);
	93	}
	94
	95	private static class TraceFillParallelogram extends FillParallelogram {
	96	FillParallelogram target;
	97
	98	public TraceFillParallelogram(FillParallelogram target) {
	99	super(target.getSourceType(),
	100	target.getCompositeType(),
	101	target.getDestType());
	102	this.target = target;
	103	}
	104
	105	public GraphicsPrimitive traceWrap() {
	106	return this;
	107	}
	108
	109	public void FillParallelogram(SunGraphics2D sg2d, SurfaceData dest,
	110	double x0, double y0,
	111	double dx1, double dy1,
	112	double dx2, double dy2)
	113	{
	114	tracePrimitive(target);
	115	target.FillParallelogram(sg2d, dest, x0, y0, dx1, dy1, dx2, dy2);
	116	}
	117	}
	118	}

java/pkg/sun/java2d/loops/FillPath$TraceFillPath.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillPath.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillPath.java+114−0

@@ -0,0 +1,114 @@
	1	/*
	2	* Copyright (c) 2005, 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.loops;
	27
	28	import sun.java2d.loops.GraphicsPrimitive;
	29	import sun.java2d.SunGraphics2D;
	30	import sun.java2d.SurfaceData;
	31	import java.awt.geom.Path2D;
	32
	33	/**
	34	* FillPath
	35	* 1. fill path onto destination surface
	36	* 2. must accept output area [x, y, dx, dy]
	37	* from within the surface description data for clip rect
	38	*/
	39	public class FillPath extends GraphicsPrimitive {
	40
	41	public final static String methodSignature =
	42	"FillPath(...)".toString();
	43
	44	public final static int primTypeID = makePrimTypeID();
	45
	46	public static FillPath locate(SurfaceType srctype,
	47	CompositeType comptype,
	48	SurfaceType dsttype)
	49	{
	50	return (FillPath)
	51	GraphicsPrimitiveMgr.locate(primTypeID,
	52	srctype, comptype, dsttype);
	53	}
	54
	55	protected FillPath(SurfaceType srctype,
	56	CompositeType comptype,
	57	SurfaceType dsttype)
	58	{
	59	super(methodSignature, primTypeID,
	60	srctype, comptype, dsttype);
	61	}
	62
	63	public FillPath(long pNativePrim,
	64	SurfaceType srctype,
	65	CompositeType comptype,
	66	SurfaceType dsttype)
	67	{
	68	super(pNativePrim, methodSignature, primTypeID,
	69	srctype, comptype, dsttype);
	70	}
	71
	72
	73	/**
	74	* All FillPath implementors must have this invoker method
	75	*/
	76	public native void FillPath(SunGraphics2D sg2d, SurfaceData sData,
	77	int transX, int transY,
	78	Path2D.Float p2df);
	79
	80	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	81	CompositeType comptype,
	82	SurfaceType dsttype)
	83	{
	84	throw new InternalError("FillPath not implemented for "+
	85	srctype+" with "+comptype);
	86	}
	87
	88	public GraphicsPrimitive traceWrap() {
	89	return new TraceFillPath(this);
	90	}
	91
	92	private static class TraceFillPath extends FillPath {
	93	FillPath target;
	94
	95	public TraceFillPath(FillPath target) {
	96	super(target.getSourceType(),
	97	target.getCompositeType(),
	98	target.getDestType());
	99	this.target = target;
	100	}
	101
	102	public GraphicsPrimitive traceWrap() {
	103	return this;
	104	}
	105
	106	public void FillPath(SunGraphics2D sg2d, SurfaceData sData,
	107	int transX, int transY,
	108	Path2D.Float p2df)
	109	{
	110	tracePrimitive(target);
	111	target.FillPath(sg2d, sData, transX, transY, p2df);
	112	}
	113	}
	114	}

java/pkg/sun/java2d/loops/FillRect$General.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillRect$TraceFillRect.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillRect.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillRect.java+135−0

@@ -0,0 +1,135 @@
	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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import java.awt.Color;
	34	import java.awt.image.ColorModel;
	35	import java.awt.image.Raster;
	36	import sun.java2d.SunGraphics2D;
	37	import sun.java2d.SurfaceData;
	38
	39	/**
	40	* FillRect
	41	* 1) draw solid color rectangle onto destination surface
	42	* 2) must accept output area [x, y, dx, dy]
	43	* from within the surface description data for clip rect
	44	*/
	45	public class FillRect extends GraphicsPrimitive
	46	{
	47	public final static String methodSignature = "FillRect(...)".toString();
	48
	49	public final static int primTypeID = makePrimTypeID();
	50
	51	public static FillRect locate(SurfaceType srctype,
	52	CompositeType comptype,
	53	SurfaceType dsttype)
	54	{
	55	return (FillRect)
	56	GraphicsPrimitiveMgr.locate(primTypeID,
	57	srctype, comptype, dsttype);
	58	}
	59
	60	protected FillRect(SurfaceType srctype,
	61	CompositeType comptype,
	62	SurfaceType dsttype)
	63	{
	64	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	65	}
	66
	67	public FillRect(long pNativePrim,
	68	SurfaceType srctype,
	69	CompositeType comptype,
	70	SurfaceType dsttype)
	71	{
	72	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	73	}
	74
	75	/**
	76	* All FillRect implementors must have this invoker method
	77	*/
	78	public native void FillRect(SunGraphics2D sg2d, SurfaceData dest,
	79	int x, int y, int w, int h);
	80
	81	static {
	82	GraphicsPrimitiveMgr.registerGeneral(new FillRect(null, null, null));
	83	}
	84
	85	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	86	CompositeType comptype,
	87	SurfaceType dsttype)
	88	{
	89	return new General(srctype, comptype, dsttype);
	90	}
	91
	92	public static class General extends FillRect {
	93	public MaskFill fillop;
	94
	95	public General(SurfaceType srctype,
	96	CompositeType comptype,
	97	SurfaceType dsttype)
	98	{
	99	super(srctype, comptype, dsttype);
	100	fillop = MaskFill.locate(srctype, comptype, dsttype);
	101	}
	102
	103	public void FillRect(SunGraphics2D sg2d, SurfaceData dest,
	104	int x, int y, int w, int h)
	105	{
	106	fillop.MaskFill(sg2d, dest, sg2d.composite, x, y, w, h, null, 0, 0);
	107	}
	108	}
	109
	110	public GraphicsPrimitive traceWrap() {
	111	return new TraceFillRect(this);
	112	}
	113
	114	private static class TraceFillRect extends FillRect {
	115	FillRect target;
	116
	117	public TraceFillRect(FillRect target) {
	118	super(target.getSourceType(),
	119	target.getCompositeType(),
	120	target.getDestType());
	121	this.target = target;
	122	}
	123
	124	public GraphicsPrimitive traceWrap() {
	125	return this;
	126	}
	127
	128	public void FillRect(SunGraphics2D sg2d, SurfaceData dest,
	129	int x, int y, int w, int h)
	130	{
	131	tracePrimitive(target);
	132	target.FillRect(sg2d, dest, x, y, w, h);
	133	}
	134	}
	135	}

java/pkg/sun/java2d/loops/FillSpans$TraceFillSpans.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillSpans.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FillSpans.java+122−0

@@ -0,0 +1,122 @@
	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	/*
	27	* @author Jim Graham
	28	* @author Charlton Innovations, Inc.
	29	*/
	30
	31	package sun.java2d.loops;
	32
	33	import sun.java2d.loops.GraphicsPrimitive;
	34	import sun.java2d.pipe.SpanIterator;
	35	import java.awt.Color;
	36	import java.awt.image.ColorModel;
	37	import java.awt.image.Raster;
	38	import sun.java2d.SunGraphics2D;
	39	import sun.java2d.SurfaceData;
	40
	41	/**
	42	* FillSpans
	43	* 1) draw solid color onto destination surface
	44	* 2) rectangular areas to fill come from SpanIterator
	45	*/
	46	public class FillSpans extends GraphicsPrimitive
	47	{
	48	public final static String methodSignature = "FillSpans(...)".toString();
	49
	50	public final static int primTypeID = makePrimTypeID();
	51
	52	public static FillSpans locate(SurfaceType srctype,
	53	CompositeType comptype,
	54	SurfaceType dsttype)
	55	{
	56	return (FillSpans)
	57	GraphicsPrimitiveMgr.locate(primTypeID,
	58	srctype, comptype, dsttype);
	59	}
	60
	61	protected FillSpans(SurfaceType srctype,
	62	CompositeType comptype,
	63	SurfaceType dsttype)
	64	{
	65	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	66	}
	67
	68	public FillSpans(long pNativePrim,
	69	SurfaceType srctype,
	70	CompositeType comptype,
	71	SurfaceType dsttype)
	72	{
	73	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	74	}
	75
	76	private native void FillSpans(SunGraphics2D sg2d, SurfaceData dest,
	77	int pixel, long pIterator, SpanIterator si);
	78
	79	/**
	80	* All FillSpan implementors must have this invoker method
	81	*/
	82	public void FillSpans(SunGraphics2D sg2d, SurfaceData dest,
	83	SpanIterator si)
	84	{
	85	FillSpans(sg2d, dest, sg2d.pixel, si.getNativeIterator(), si);
	86	}
	87
	88	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	89	CompositeType comptype,
	90	SurfaceType dsttype)
	91	{
	92	// REMIND: iterate with a FillRect primitive?
	93	throw new InternalError("FillSpans not implemented for "+
	94	srctype+" with "+comptype);
	95	}
	96
	97	public GraphicsPrimitive traceWrap() {
	98	return new TraceFillSpans(this);
	99	}
	100
	101	private static class TraceFillSpans extends FillSpans {
	102	FillSpans target;
	103
	104	public TraceFillSpans(FillSpans target) {
	105	super(target.getSourceType(),
	106	target.getCompositeType(),
	107	target.getDestType());
	108	this.target = target;
	109	}
	110
	111	public GraphicsPrimitive traceWrap() {
	112	return this;
	113	}
	114
	115	public void FillSpans(SunGraphics2D sg2d, SurfaceData dest,
	116	SpanIterator si)
	117	{
	118	tracePrimitive(target);
	119	target.FillSpans(sg2d, dest, si);
	120	}
	121	}
	122	}

java/pkg/sun/java2d/loops/FontInfo.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/FontInfo.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 1999, 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.loops;
	27
	28	import java.awt.Font;
	29	import java.awt.geom.AffineTransform;
	30
	31	import sun.font.Font2D;
	32	import sun.font.FontStrike;
	33	import sun.font.FontStrikeDesc;
	34
	35	/*
	36	* A FontInfo object holds all calculated or derived data needed
	37	* to handle rendering operations based on a particular set of
	38	* Graphics2D rendering attributes.
	39	* Note that this does not use a Font2DHandle, and also has a reference
	40	* to the strike which also references the Font2D.
	41	* So presently, until SG2D objects no longer reference this FontInfo,
	42	* there is still some potential for a bad Font2D to be used for a short
	43	* time. I am reluctant to add the overhead of that machinery here without
	44	* a proven benefit.
	45	*/
	46	public class FontInfo implements Cloneable {
	47	public Font font;
	48	public Font2D font2D;
	49	public FontStrike fontStrike;
	50	public double[] devTx;
	51	public double[] glyphTx;
	52	public int pixelHeight;
	53	public float originX;
	54	public float originY;
	55	public int aaHint;
	56	public boolean lcdRGBOrder;
	57	/* lcdSubPixPos is used if FM is ON for HRGB/HBGR LCD text mode */
	58	public boolean lcdSubPixPos;
	59
	60	public String mtx(double[] matrix) {
	61	return ("["+
	62	matrix[0]+", "+
	63	matrix[1]+", "+
	64	matrix[2]+", "+
	65	matrix[3]+
	66	"]");
	67	}
	68
	69	public Object clone() {
	70	try {
	71	return super.clone();
	72	} catch (CloneNotSupportedException e) {
	73	return null;
	74	}
	75	}
	76
	77	public String toString() {
	78	return ("FontInfo["+
	79	"font="+font+", "+
	80	"devTx="+mtx(devTx)+", "+
	81	"glyphTx="+mtx(glyphTx)+", "+
	82	"pixelHeight="+pixelHeight+", "+
	83	"origin=("+originX+","+originY+"), "+
	84	"aaHint="+aaHint+", "+
	85	"lcdRGBOrder="+(lcdRGBOrder ? "RGB" : "BGR")+
	86	"lcdSubPixPos="+lcdSubPixPos+
	87	"]");
	88	}
	89	}

java/pkg/sun/java2d/loops/GeneralRenderer.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GeneralRenderer.java+1125−0

@@ -0,0 +1,1125 @@
	1	/*
	2	* Copyright (c) 1998, 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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import java.awt.image.WritableRaster;
	33	import java.awt.image.DataBuffer;
	34	import java.awt.image.ColorModel;
	35	import java.awt.geom.Path2D;
	36	import java.awt.geom.PathIterator;
	37	import java.awt.geom.AffineTransform;
	38	import sun.java2d.pipe.Region;
	39	import sun.java2d.pipe.SpanIterator;
	40	import sun.java2d.SunGraphics2D;
	41	import sun.java2d.SurfaceData;
	42	import sun.java2d.loops.ProcessPath;
	43	import sun.font.GlyphList;
	44
	45	/**
	46	* GeneralRenderer collection
	47	* Basically, a collection of components which permit basic
	48	* rendering to occur on rasters of any format
	49	*/
	50
	51	public final class GeneralRenderer {
	52	public static void register() {
	53	Class owner = GeneralRenderer.class;
	54	GraphicsPrimitive[] primitives = {
	55	new GraphicsPrimitiveProxy(owner, "SetFillRectANY",
	56	FillRect.methodSignature,
	57	FillRect.primTypeID,
	58	SurfaceType.AnyColor,
	59	CompositeType.SrcNoEa,
	60	SurfaceType.Any),
	61	new GraphicsPrimitiveProxy(owner, "SetFillPathANY",
	62	FillPath.methodSignature,
	63	FillPath.primTypeID,
	64	SurfaceType.AnyColor,
	65	CompositeType.SrcNoEa,
	66	SurfaceType.Any),
	67	new GraphicsPrimitiveProxy(owner, "SetFillSpansANY",
	68	FillSpans.methodSignature,
	69	FillSpans.primTypeID,
	70	SurfaceType.AnyColor,
	71	CompositeType.SrcNoEa,
	72	SurfaceType.Any),
	73	new GraphicsPrimitiveProxy(owner, "SetDrawLineANY",
	74	DrawLine.methodSignature,
	75	DrawLine.primTypeID,
	76	SurfaceType.AnyColor,
	77	CompositeType.SrcNoEa,
	78	SurfaceType.Any),
	79	new GraphicsPrimitiveProxy(owner, "SetDrawPolygonsANY",
	80	DrawPolygons.methodSignature,
	81	DrawPolygons.primTypeID,
	82	SurfaceType.AnyColor,
	83	CompositeType.SrcNoEa,
	84	SurfaceType.Any),
	85	new GraphicsPrimitiveProxy(owner, "SetDrawPathANY",
	86	DrawPath.methodSignature,
	87	DrawPath.primTypeID,
	88	SurfaceType.AnyColor,
	89	CompositeType.SrcNoEa,
	90	SurfaceType.Any),
	91	new GraphicsPrimitiveProxy(owner, "SetDrawRectANY",
	92	DrawRect.methodSignature,
	93	DrawRect.primTypeID,
	94	SurfaceType.AnyColor,
	95	CompositeType.SrcNoEa,
	96	SurfaceType.Any),
	97
	98	new GraphicsPrimitiveProxy(owner, "XorFillRectANY",
	99	FillRect.methodSignature,
	100	FillRect.primTypeID,
	101	SurfaceType.AnyColor,
	102	CompositeType.Xor,
	103	SurfaceType.Any),
	104	new GraphicsPrimitiveProxy(owner, "XorFillPathANY",
	105	FillPath.methodSignature,
	106	FillPath.primTypeID,
	107	SurfaceType.AnyColor,
	108	CompositeType.Xor,
	109	SurfaceType.Any),
	110	new GraphicsPrimitiveProxy(owner, "XorFillSpansANY",
	111	FillSpans.methodSignature,
	112	FillSpans.primTypeID,
	113	SurfaceType.AnyColor,
	114	CompositeType.Xor,
	115	SurfaceType.Any),
	116	new GraphicsPrimitiveProxy(owner, "XorDrawLineANY",
	117	DrawLine.methodSignature,
	118	DrawLine.primTypeID,
	119	SurfaceType.AnyColor,
	120	CompositeType.Xor,
	121	SurfaceType.Any),
	122	new GraphicsPrimitiveProxy(owner, "XorDrawPolygonsANY",
	123	DrawPolygons.methodSignature,
	124	DrawPolygons.primTypeID,
	125	SurfaceType.AnyColor,
	126	CompositeType.Xor,
	127	SurfaceType.Any),
	128	new GraphicsPrimitiveProxy(owner, "XorDrawPathANY",
	129	DrawPath.methodSignature,
	130	DrawPath.primTypeID,
	131	SurfaceType.AnyColor,
	132	CompositeType.Xor,
	133	SurfaceType.Any),
	134	new GraphicsPrimitiveProxy(owner, "XorDrawRectANY",
	135	DrawRect.methodSignature,
	136	DrawRect.primTypeID,
	137	SurfaceType.AnyColor,
	138	CompositeType.Xor,
	139	SurfaceType.Any),
	140	new GraphicsPrimitiveProxy(owner, "XorDrawGlyphListANY",
	141	DrawGlyphList.methodSignature,
	142	DrawGlyphList.primTypeID,
	143	SurfaceType.AnyColor,
	144	CompositeType.Xor,
	145	SurfaceType.Any),
	146	new GraphicsPrimitiveProxy(owner, "XorDrawGlyphListAAANY",
	147	DrawGlyphListAA.methodSignature,
	148	DrawGlyphListAA.primTypeID,
	149	SurfaceType.AnyColor,
	150	CompositeType.Xor,
	151	SurfaceType.Any),
	152	};
	153	GraphicsPrimitiveMgr.register(primitives);
	154	}
	155
	156	static void doDrawPoly(SurfaceData sData, PixelWriter pw,
	157	int xPoints[], int yPoints[], int off, int nPoints,
	158	Region clip, int transx, int transy, boolean close)
	159	{
	160	int mx, my, x1, y1;
	161	int[] tmp = null;
	162
	163	if (nPoints <= 0) {
	164	return;
	165	}
	166	mx = x1 = xPoints[off] + transx;
	167	my = y1 = yPoints[off] + transy;
	168	while (--nPoints > 0) {
	169	++off;
	170	int x2 = xPoints[off] + transx;
	171	int y2 = yPoints[off] + transy;
	172	tmp = GeneralRenderer.doDrawLine(sData, pw, tmp, clip,
	173	x1, y1, x2, y2);
	174	x1 = x2;
	175	y1 = y2;
	176	}
	177	if (close && (x1 != mx \|\| y1 != my)) {
	178	tmp = GeneralRenderer.doDrawLine(sData, pw, tmp, clip,
	179	x1, y1, mx, my);
	180	}
	181	}
	182
	183	static void doSetRect(SurfaceData sData, PixelWriter pw,
	184	int x1, int y1, int x2, int y2) {
	185	WritableRaster dstRast =
	186	(WritableRaster) sData.getRaster(x1, y1, x2-x1, y2-y1);
	187	pw.setRaster(dstRast);
	188
	189	while (y1 < y2) {
	190	for (int x = x1; x < x2; x++) {
	191	pw.writePixel(x, y1);
	192	}
	193	y1++;
	194	}
	195	}
	196
	197	static int[] doDrawLine(SurfaceData sData, PixelWriter pw, int[] boundPts,
	198	Region clip,
	199	int origx1, int origy1, int origx2, int origy2)
	200	{
	201	if (boundPts == null) {
	202	boundPts = new int[8];
	203	}
	204	boundPts[0] = origx1;
	205	boundPts[1] = origy1;
	206	boundPts[2] = origx2;
	207	boundPts[3] = origy2;
	208	if (!adjustLine(boundPts,
	209	clip.getLoX(), clip.getLoY(),
	210	clip.getHiX(), clip.getHiY()))
	211	{
	212	return boundPts;
	213	}
	214	int x1 = boundPts[0];
	215	int y1 = boundPts[1];
	216	int x2 = boundPts[2];
	217	int y2 = boundPts[3];
	218
	219	WritableRaster dstRast = (WritableRaster)
	220	sData.getRaster(Math.min(x1, x2), Math.min(y1, y2),
	221	Math.abs(x1 - x2) + 1, Math.abs(y1 - y2) + 1);
	222	pw.setRaster(dstRast);
	223
	224	/* this could be made smaller, more elegant, more traditional. */
	225	if (x1 == x2) {
	226	if (y1 > y2) {
	227	do {
	228	pw.writePixel(x1, y1);
	229	y1--;
	230	} while (y1 >= y2);
	231	} else {
	232	do {
	233	pw.writePixel(x1, y1);
	234	y1++;
	235	} while (y1 <= y2);
	236	}
	237	} else if (y1 == y2) {
	238	if (x1 > x2) {
	239	do {
	240	pw.writePixel(x1, y1);
	241	x1--;
	242	} while (x1 >= x2);
	243	} else {
	244	do {
	245	pw.writePixel(x1, y1);
	246	x1++;
	247	} while (x1 <= x2);
	248	}
	249	} else {
	250	int dx = boundPts[4];
	251	int dy = boundPts[5];
	252	int ax = boundPts[6];
	253	int ay = boundPts[7];
	254	int steps;
	255	int bumpmajor;
	256	int bumpminor;
	257	int errminor;
	258	int errmajor;
	259	int error;
	260	boolean xmajor;
	261
	262	if (ax >= ay) {
	263	/* x is dominant */
	264	xmajor = true;
	265	errmajor = ay * 2;
	266	errminor = ax * 2;
	267	bumpmajor = (dx < 0) ? -1 : 1;
	268	bumpminor = (dy < 0) ? -1 : 1;
	269	ax = -ax; /* For clipping adjustment below */
	270	steps = x2 - x1;
	271	} else {
	272	/* y is dominant */
	273	xmajor = false;
	274	errmajor = ax * 2;
	275	errminor = ay * 2;
	276	bumpmajor = (dy < 0) ? -1 : 1;
	277	bumpminor = (dx < 0) ? -1 : 1;
	278	ay = -ay; /* For clipping adjustment below */
	279	steps = y2 - y1;
	280	}
	281	error = - (errminor / 2);
	282	if (y1 != origy1) {
	283	int ysteps = y1 - origy1;
	284	if (ysteps < 0) {
	285	ysteps = -ysteps;
	286	}
	287	error += ysteps * ax * 2;
	288	}
	289	if (x1 != origx1) {
	290	int xsteps = x1 - origx1;
	291	if (xsteps < 0) {
	292	xsteps = -xsteps;
	293	}
	294	error += xsteps * ay * 2;
	295	}
	296	if (steps < 0) {
	297	steps = -steps;
	298	}
	299	if (xmajor) {
	300	do {
	301	pw.writePixel(x1, y1);
	302	x1 += bumpmajor;
	303	error += errmajor;
	304	if (error >= 0) {
	305	y1 += bumpminor;
	306	error -= errminor;
	307	}
	308	} while (--steps >= 0);
	309	} else {
	310	do {
	311	pw.writePixel(x1, y1);
	312	y1 += bumpmajor;
	313	error += errmajor;
	314	if (error >= 0) {
	315	x1 += bumpminor;
	316	error -= errminor;
	317	}
	318	} while (--steps >= 0);
	319	}
	320	}
	321	return boundPts;
	322	}
	323
	324	public static void doDrawRect(PixelWriter pw,
	325	SunGraphics2D sg2d, SurfaceData sData,
	326	int x, int y, int w, int h)
	327	{
	328	if (w < 0 \|\| h < 0) {
	329	return;
	330	}
	331	int x2 = Region.dimAdd(Region.dimAdd(x, w), 1);
	332	int y2 = Region.dimAdd(Region.dimAdd(y, h), 1);
	333	Region r = sg2d.getCompClip().getBoundsIntersectionXYXY(x, y, x2, y2);
	334	if (r.isEmpty()) {
	335	return;
	336	}
	337	int cx1 = r.getLoX();
	338	int cy1 = r.getLoY();
	339	int cx2 = r.getHiX();
	340	int cy2 = r.getHiY();
	341
	342	if (w < 2 \|\| h < 2) {
	343	doSetRect(sData, pw, cx1, cy1, cx2, cy2);
	344	return;
	345	}
	346
	347
	348	if (cy1 == y) {
	349	doSetRect(sData, pw, cx1, cy1, cx2, cy1+1);
	350	}
	351	if (cx1 == x) {
	352	doSetRect(sData, pw, cx1, cy1+1, cx1+1, cy2-1);
	353	}
	354	if (cx2 == x2) {
	355	doSetRect(sData, pw, cx2-1, cy1+1, cx2, cy2-1);
	356	}
	357	if (cy2 == y2) {
	358	doSetRect(sData, pw, cx1, cy2-1, cx2, cy2);
	359	}
	360	}
	361
	362	/*
	363	* REMIND: For now this will field both AA and non-AA requests and
	364	* use a simple threshold to choose pixels if the supplied grey
	365	* bits are antialiased. We should really find a way to disable
	366	* AA text at a higher level or to have the GlyphList be able to
	367	* reset the glyphs to non-AA after construction.
	368	*/
	369	static void doDrawGlyphList(SurfaceData sData, PixelWriter pw,
	370	GlyphList gl, Region clip)
	371	{
	372	int[] bounds = gl.getBounds();
	373	clip.clipBoxToBounds(bounds);
	374	int cx1 = bounds[0];
	375	int cy1 = bounds[1];
	376	int cx2 = bounds[2];
	377	int cy2 = bounds[3];
	378
	379	WritableRaster dstRast =
	380	(WritableRaster) sData.getRaster(cx1, cy1, cx2 - cx1, cy2 - cy1);
	381	pw.setRaster(dstRast);
	382
	383	int num = gl.getNumGlyphs();
	384	for (int i = 0; i < num; i++) {
	385	gl.setGlyphIndex(i);
	386	int metrics[] = gl.getMetrics();
	387	int gx1 = metrics[0];
	388	int gy1 = metrics[1];
	389	int w = metrics[2];
	390	int gx2 = gx1 + w;
	391	int gy2 = gy1 + metrics[3];
	392	int off = 0;
	393	if (gx1 < cx1) {
	394	off = cx1 - gx1;
	395	gx1 = cx1;
	396	}
	397	if (gy1 < cy1) {
	398	off += (cy1 - gy1) * w;
	399	gy1 = cy1;
	400	}
	401	if (gx2 > cx2) gx2 = cx2;
	402	if (gy2 > cy2) gy2 = cy2;
	403	if (gx2 > gx1 && gy2 > gy1) {
	404	byte alpha[] = gl.getGrayBits();
	405	w -= (gx2 - gx1);
	406	for (int y = gy1; y < gy2; y++) {
	407	for (int x = gx1; x < gx2; x++) {
	408	if (alpha[off++] < 0) {
	409	pw.writePixel(x, y);
	410	}
	411	}
	412	off += w;
	413	}
	414	}
	415	}
	416	}
	417
	418	static final int OUTCODE_TOP = 1;
	419	static final int OUTCODE_BOTTOM = 2;
	420	static final int OUTCODE_LEFT = 4;
	421	static final int OUTCODE_RIGHT = 8;
	422
	423	static int outcode(int x, int y, int xmin, int ymin, int xmax, int ymax) {
	424	int code;
	425	if (y < ymin) {
	426	code = OUTCODE_TOP;
	427	} else if (y > ymax) {
	428	code = OUTCODE_BOTTOM;
	429	} else {
	430	code = 0;
	431	}
	432	if (x < xmin) {
	433	code \|= OUTCODE_LEFT;
	434	} else if (x > xmax) {
	435	code \|= OUTCODE_RIGHT;
	436	}
	437	return code;
	438	}
	439
	440	public static boolean adjustLine(int [] boundPts,
	441	int cxmin, int cymin, int cx2, int cy2)
	442	{
	443	int cxmax = cx2 - 1;
	444	int cymax = cy2 - 1;
	445	int x1 = boundPts[0];
	446	int y1 = boundPts[1];
	447	int x2 = boundPts[2];
	448	int y2 = boundPts[3];
	449
	450	if ((cxmax < cxmin) \|\| (cymax < cymin)) {
	451	return false;
	452	}
	453
	454	if (x1 == x2) {
	455	if (x1 < cxmin \|\| x1 > cxmax) {
	456	return false;
	457	}
	458	if (y1 > y2) {
	459	int t = y1;
	460	y1 = y2;
	461	y2 = t;
	462	}
	463	if (y1 < cymin) {
	464	y1 = cymin;
	465	}
	466	if (y2 > cymax) {
	467	y2 = cymax;
	468	}
	469	if (y1 > y2) {
	470	return false;
	471	}
	472	boundPts[1] = y1;
	473	boundPts[3] = y2;
	474	} else if (y1 == y2) {
	475	if (y1 < cymin \|\| y1 > cymax) {
	476	return false;
	477	}
	478	if (x1 > x2) {
	479	int t = x1;
	480	x1 = x2;
	481	x2 = t;
	482	}
	483	if (x1 < cxmin) {
	484	x1 = cxmin;
	485	}
	486	if (x2 > cxmax) {
	487	x2 = cxmax;
	488	}
	489	if (x1 > x2) {
	490	return false;
	491	}
	492	boundPts[0] = x1;
	493	boundPts[2] = x2;
	494	} else {
	495	/* REMIND: This could overflow... */
	496	int outcode1, outcode2;
	497	int dx = x2 - x1;
	498	int dy = y2 - y1;
	499	int ax = (dx < 0) ? -dx : dx;
	500	int ay = (dy < 0) ? -dy : dy;
	501	boolean xmajor = (ax >= ay);
	502
	503	outcode1 = outcode(x1, y1, cxmin, cymin, cxmax, cymax);
	504	outcode2 = outcode(x2, y2, cxmin, cymin, cxmax, cymax);
	505	while ((outcode1 \| outcode2) != 0) {
	506	int xsteps, ysteps;
	507	if ((outcode1 & outcode2) != 0) {
	508	return false;
	509	}
	510	if (outcode1 != 0) {
	511	if (0 != (outcode1 & (OUTCODE_TOP \| OUTCODE_BOTTOM))) {
	512	if (0 != (outcode1 & OUTCODE_TOP)) {
	513	y1 = cymin;
	514	} else {
	515	y1 = cymax;
	516	}
	517	ysteps = y1 - boundPts[1];
	518	if (ysteps < 0) {
	519	ysteps = -ysteps;
	520	}
	521	xsteps = 2 * ysteps * ax + ay;
	522	if (xmajor) {
	523	xsteps += ay - ax - 1;
	524	}
	525	xsteps = xsteps / (2 * ay);
	526	if (dx < 0) {
	527	xsteps = -xsteps;
	528	}
	529	x1 = boundPts[0] + xsteps;
	530	} else if (0 !=
	531	(outcode1 & (OUTCODE_LEFT \| OUTCODE_RIGHT))) {
	532	if (0 != (outcode1 & OUTCODE_LEFT)) {
	533	x1 = cxmin;
	534	} else {
	535	x1 = cxmax;
	536	}
	537	xsteps = x1 - boundPts[0];
	538	if (xsteps < 0) {
	539	xsteps = -xsteps;
	540	}
	541	ysteps = 2 * xsteps * ay + ax;
	542	if (!xmajor) {
	543	ysteps += ax - ay - 1;
	544	}
	545	ysteps = ysteps / (2 * ax);
	546	if (dy < 0) {
	547	ysteps = -ysteps;
	548	}
	549	y1 = boundPts[1] + ysteps;
	550	}
	551	outcode1 = outcode(x1, y1, cxmin, cymin, cxmax, cymax);
	552	} else {
	553	if (0 != (outcode2 & (OUTCODE_TOP \| OUTCODE_BOTTOM))) {
	554	if (0 != (outcode2 & OUTCODE_TOP)) {
	555	y2 = cymin;
	556	} else {
	557	y2 = cymax;
	558	}
	559	ysteps = y2 - boundPts[3];
	560	if (ysteps < 0) {
	561	ysteps = -ysteps;
	562	}
	563	xsteps = 2 * ysteps * ax + ay;
	564	if (xmajor) {
	565	xsteps += ay - ax;
	566	} else {
	567	xsteps -= 1;
	568	}
	569	xsteps = xsteps / (2 * ay);
	570	if (dx > 0) {
	571	xsteps = -xsteps;
	572	}
	573	x2 = boundPts[2] + xsteps;
	574	} else if (0 !=
	575	(outcode2 & (OUTCODE_LEFT \| OUTCODE_RIGHT))) {
	576	if (0 != (outcode2 & OUTCODE_LEFT)) {
	577	x2 = cxmin;
	578	} else {
	579	x2 = cxmax;
	580	}
	581	xsteps = x2 - boundPts[2];
	582	if (xsteps < 0) {
	583	xsteps = -xsteps;
	584	}
	585	ysteps = 2 * xsteps * ay + ax;
	586	if (xmajor) {
	587	ysteps -= 1;
	588	} else {
	589	ysteps += ax - ay;
	590	}
	591	ysteps = ysteps / (2 * ax);
	592	if (dy > 0) {
	593	ysteps = -ysteps;
	594	}
	595	y2 = boundPts[3] + ysteps;
	596	}
	597	outcode2 = outcode(x2, y2, cxmin, cymin, cxmax, cymax);
	598	}
	599	}
	600	boundPts[0] = x1;
	601	boundPts[1] = y1;
	602	boundPts[2] = x2;
	603	boundPts[3] = y2;
	604	boundPts[4] = dx;
	605	boundPts[5] = dy;
	606	boundPts[6] = ax;
	607	boundPts[7] = ay;
	608	}
	609	return true;
	610	}
	611
	612	static PixelWriter createSolidPixelWriter(SunGraphics2D sg2d,
	613	SurfaceData sData)
	614	{
	615	ColorModel dstCM = sData.getColorModel();
	616	Object srcPixel = dstCM.getDataElements(sg2d.eargb, null);
	617
	618	return new SolidPixelWriter(srcPixel);
	619	}
	620
	621	static PixelWriter createXorPixelWriter(SunGraphics2D sg2d,
	622	SurfaceData sData)
	623	{
	624	ColorModel dstCM = sData.getColorModel();
	625
	626	Object srcPixel = dstCM.getDataElements(sg2d.eargb, null);
	627
	628	XORComposite comp = (XORComposite)sg2d.getComposite();
	629	int xorrgb = comp.getXorColor().getRGB();
	630	Object xorPixel = dstCM.getDataElements(xorrgb, null);
	631
	632	switch (dstCM.getTransferType()) {
	633	case DataBuffer.TYPE_BYTE:
	634	return new XorPixelWriter.ByteData(srcPixel, xorPixel);
	635	case DataBuffer.TYPE_SHORT:
	636	case DataBuffer.TYPE_USHORT:
	637	return new XorPixelWriter.ShortData(srcPixel, xorPixel);
	638	case DataBuffer.TYPE_INT:
	639	return new XorPixelWriter.IntData(srcPixel, xorPixel);
	640	case DataBuffer.TYPE_FLOAT:
	641	return new XorPixelWriter.FloatData(srcPixel, xorPixel);
	642	case DataBuffer.TYPE_DOUBLE:
	643	return new XorPixelWriter.DoubleData(srcPixel, xorPixel);
	644	default:
	645	throw new InternalError("Unsupported XOR pixel type");
	646	}
	647	}
	648	}
	649
	650	class SetFillRectANY extends FillRect {
	651	SetFillRectANY() {
	652	super(SurfaceType.AnyColor,
	653	CompositeType.SrcNoEa,
	654	SurfaceType.Any);
	655	}
	656
	657	public void FillRect(SunGraphics2D sg2d, SurfaceData sData,
	658	int x, int y, int w, int h)
	659	{
	660	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	661
	662	Region r = sg2d.getCompClip().getBoundsIntersectionXYWH(x, y, w, h);
	663
	664	GeneralRenderer.doSetRect(sData, pw,
	665	r.getLoX(), r.getLoY(),
	666	r.getHiX(), r.getHiY());
	667	}
	668	}
	669
	670	class PixelWriterDrawHandler extends ProcessPath.DrawHandler {
	671	PixelWriter pw;
	672	SurfaceData sData;
	673	Region clip;
	674
	675	public PixelWriterDrawHandler(SurfaceData sData, PixelWriter pw,
	676	Region clip, int strokeHint) {
	677	super(clip.getLoX(), clip.getLoY(),
	678	clip.getHiX(), clip.getHiY(),
	679	strokeHint);
	680	this.sData = sData;
	681	this.pw = pw;
	682	this.clip = clip;
	683	}
	684
	685	public void drawLine(int x0, int y0, int x1, int y1) {
	686	GeneralRenderer.doDrawLine(sData, pw, null, clip,
	687	x0, y0, x1, y1);
	688	}
	689
	690	public void drawPixel(int x0, int y0) {
	691	GeneralRenderer.doSetRect(sData, pw, x0, y0, x0 + 1, y0 + 1);
	692	}
	693
	694	public void drawScanline(int x0, int x1, int y0) {
	695	GeneralRenderer.doSetRect(sData, pw, x0, y0, x1 + 1, y0 + 1);
	696	}
	697	}
	698
	699	class SetFillPathANY extends FillPath {
	700	SetFillPathANY() {
	701	super(SurfaceType.AnyColor, CompositeType.SrcNoEa,
	702	SurfaceType.Any);
	703	}
	704
	705	public void FillPath(SunGraphics2D sg2d, SurfaceData sData,
	706	int transx, int transy,
	707	Path2D.Float p2df)
	708	{
	709	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	710	ProcessPath.fillPath(
	711	new PixelWriterDrawHandler(sData, pw, sg2d.getCompClip(),
	712	sg2d.strokeHint),
	713	p2df, transx, transy);
	714	}
	715	}
	716
	717	class SetFillSpansANY extends FillSpans {
	718	SetFillSpansANY() {
	719	super(SurfaceType.AnyColor,
	720	CompositeType.SrcNoEa,
	721	SurfaceType.Any);
	722	}
	723
	724	public void FillSpans(SunGraphics2D sg2d, SurfaceData sData,
	725	SpanIterator si)
	726	{
	727	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	728
	729	int span[] = new int[4];
	730	while (si.nextSpan(span)) {
	731	GeneralRenderer.doSetRect(sData, pw,
	732	span[0], span[1], span[2], span[3]);
	733	}
	734	}
	735	}
	736
	737	class SetDrawLineANY extends DrawLine {
	738	SetDrawLineANY() {
	739	super(SurfaceType.AnyColor,
	740	CompositeType.SrcNoEa,
	741	SurfaceType.Any);
	742	}
	743
	744	public void DrawLine(SunGraphics2D sg2d, SurfaceData sData,
	745	int x1, int y1, int x2, int y2)
	746	{
	747	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	748
	749	if (y1 >= y2) {
	750	GeneralRenderer.doDrawLine(sData, pw, null,
	751	sg2d.getCompClip(),
	752	x2, y2, x1, y1);
	753	} else {
	754	GeneralRenderer.doDrawLine(sData, pw, null,
	755	sg2d.getCompClip(),
	756	x1, y1, x2, y2);
	757	}
	758	}
	759	}
	760
	761	class SetDrawPolygonsANY extends DrawPolygons {
	762	SetDrawPolygonsANY() {
	763	super(SurfaceType.AnyColor,
	764	CompositeType.SrcNoEa,
	765	SurfaceType.Any);
	766	}
	767
	768	public void DrawPolygons(SunGraphics2D sg2d, SurfaceData sData,
	769	int xPoints[], int yPoints[],
	770	int nPoints[], int numPolys,
	771	int transx, int transy,
	772	boolean close)
	773	{
	774	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	775
	776	int off = 0;
	777	Region clip = sg2d.getCompClip();
	778	for (int i = 0; i < numPolys; i++) {
	779	int numpts = nPoints[i];
	780	GeneralRenderer.doDrawPoly(sData, pw,
	781	xPoints, yPoints, off, numpts,
	782	clip, transx, transy, close);
	783	off += numpts;
	784	}
	785	}
	786	}
	787
	788	class SetDrawPathANY extends DrawPath {
	789	SetDrawPathANY() {
	790	super(SurfaceType.AnyColor,
	791	CompositeType.SrcNoEa,
	792	SurfaceType.Any);
	793	}
	794
	795	public void DrawPath(SunGraphics2D sg2d, SurfaceData sData,
	796	int transx, int transy,
	797	Path2D.Float p2df)
	798	{
	799	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	800	ProcessPath.drawPath(
	801	new PixelWriterDrawHandler(sData, pw, sg2d.getCompClip(),
	802	sg2d.strokeHint),
	803	p2df, transx, transy
	804	);
	805	}
	806	}
	807
	808	class SetDrawRectANY extends DrawRect {
	809	SetDrawRectANY() {
	810	super(SurfaceType.AnyColor,
	811	CompositeType.SrcNoEa,
	812	SurfaceType.Any);
	813	}
	814
	815	public void DrawRect(SunGraphics2D sg2d, SurfaceData sData,
	816	int x, int y, int w, int h)
	817	{
	818	PixelWriter pw = GeneralRenderer.createSolidPixelWriter(sg2d, sData);
	819
	820	GeneralRenderer.doDrawRect(pw, sg2d, sData, x, y, w, h);
	821	}
	822	}
	823
	824	class XorFillRectANY extends FillRect {
	825	XorFillRectANY() {
	826	super(SurfaceType.AnyColor,
	827	CompositeType.Xor,
	828	SurfaceType.Any);
	829	}
	830
	831	public void FillRect(SunGraphics2D sg2d, SurfaceData sData,
	832	int x, int y, int w, int h)
	833	{
	834	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	835
	836	Region r = sg2d.getCompClip().getBoundsIntersectionXYWH(x, y, w, h);
	837
	838	GeneralRenderer.doSetRect(sData, pw,
	839	r.getLoX(), r.getLoY(),
	840	r.getHiX(), r.getHiY());
	841	}
	842	}
	843
	844	class XorFillPathANY extends FillPath {
	845	XorFillPathANY() {
	846	super(SurfaceType.AnyColor, CompositeType.Xor,
	847	SurfaceType.Any);
	848	}
	849
	850	public void FillPath(SunGraphics2D sg2d, SurfaceData sData,
	851	int transx, int transy,
	852	Path2D.Float p2df)
	853	{
	854	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	855	ProcessPath.fillPath(
	856	new PixelWriterDrawHandler(sData, pw, sg2d.getCompClip(),
	857	sg2d.strokeHint),
	858	p2df, transx, transy);
	859	}
	860	}
	861
	862	class XorFillSpansANY extends FillSpans {
	863	XorFillSpansANY() {
	864	super(SurfaceType.AnyColor,
	865	CompositeType.Xor,
	866	SurfaceType.Any);
	867	}
	868
	869	public void FillSpans(SunGraphics2D sg2d, SurfaceData sData,
	870	SpanIterator si)
	871	{
	872	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	873
	874	int span[] = new int[4];
	875	while (si.nextSpan(span)) {
	876	GeneralRenderer.doSetRect(sData, pw,
	877	span[0], span[1], span[2], span[3]);
	878	}
	879	}
	880	}
	881
	882	class XorDrawLineANY extends DrawLine {
	883	XorDrawLineANY() {
	884	super(SurfaceType.AnyColor,
	885	CompositeType.Xor,
	886	SurfaceType.Any);
	887	}
	888
	889	public void DrawLine(SunGraphics2D sg2d, SurfaceData sData,
	890	int x1, int y1, int x2, int y2)
	891	{
	892	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	893
	894	if (y1 >= y2) {
	895	GeneralRenderer.doDrawLine(sData, pw, null,
	896	sg2d.getCompClip(),
	897	x2, y2, x1, y1);
	898	} else {
	899	GeneralRenderer.doDrawLine(sData, pw, null,
	900	sg2d.getCompClip(),
	901	x1, y1, x2, y2);
	902	}
	903	}
	904	}
	905
	906	class XorDrawPolygonsANY extends DrawPolygons {
	907	XorDrawPolygonsANY() {
	908	super(SurfaceType.AnyColor,
	909	CompositeType.Xor,
	910	SurfaceType.Any);
	911	}
	912
	913	public void DrawPolygons(SunGraphics2D sg2d, SurfaceData sData,
	914	int xPoints[], int yPoints[],
	915	int nPoints[], int numPolys,
	916	int transx, int transy,
	917	boolean close)
	918	{
	919	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	920
	921	int off = 0;
	922	Region clip = sg2d.getCompClip();
	923	for (int i = 0; i < numPolys; i++) {
	924	int numpts = nPoints[i];
	925	GeneralRenderer.doDrawPoly(sData, pw,
	926	xPoints, yPoints, off, numpts,
	927	clip, transx, transy, close);
	928	off += numpts;
	929	}
	930	}
	931	}
	932
	933	class XorDrawPathANY extends DrawPath {
	934	XorDrawPathANY() {
	935	super(SurfaceType.AnyColor,
	936	CompositeType.Xor,
	937	SurfaceType.Any);
	938	}
	939
	940	public void DrawPath(SunGraphics2D sg2d, SurfaceData sData,
	941	int transx, int transy, Path2D.Float p2df)
	942	{
	943	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	944	ProcessPath.drawPath(
	945	new PixelWriterDrawHandler(sData, pw, sg2d.getCompClip(),
	946	sg2d.strokeHint),
	947	p2df, transx, transy
	948	);
	949	}
	950	}
	951
	952	class XorDrawRectANY extends DrawRect {
	953	XorDrawRectANY() {
	954	super(SurfaceType.AnyColor,
	955	CompositeType.Xor,
	956	SurfaceType.Any);
	957	}
	958
	959	public void DrawRect(SunGraphics2D sg2d, SurfaceData sData,
	960	int x, int y, int w, int h)
	961	{
	962	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	963
	964	GeneralRenderer.doDrawRect(pw, sg2d, sData, x, y, w, h);
	965	}
	966	}
	967
	968	class XorDrawGlyphListANY extends DrawGlyphList {
	969	XorDrawGlyphListANY() {
	970	super(SurfaceType.AnyColor,
	971	CompositeType.Xor,
	972	SurfaceType.Any);
	973	}
	974
	975	public void DrawGlyphList(SunGraphics2D sg2d, SurfaceData sData,
	976	GlyphList gl)
	977	{
	978	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	979	GeneralRenderer.doDrawGlyphList(sData, pw, gl, sg2d.getCompClip());
	980	}
	981	}
	982
	983	class XorDrawGlyphListAAANY extends DrawGlyphListAA {
	984	XorDrawGlyphListAAANY() {
	985	super(SurfaceType.AnyColor,
	986	CompositeType.Xor,
	987	SurfaceType.Any);
	988	}
	989
	990	public void DrawGlyphListAA(SunGraphics2D sg2d, SurfaceData sData,
	991	GlyphList gl)
	992	{
	993	PixelWriter pw = GeneralRenderer.createXorPixelWriter(sg2d, sData);
	994	GeneralRenderer.doDrawGlyphList(sData, pw, gl, sg2d.getCompClip());
	995	}
	996	}
	997
	998	abstract class PixelWriter {
	999	protected WritableRaster dstRast;
	1000
	1001	public void setRaster(WritableRaster dstRast) {
	1002	this.dstRast = dstRast;
	1003	}
	1004
	1005	public abstract void writePixel(int x, int y);
	1006	}
	1007
	1008	class SolidPixelWriter extends PixelWriter {
	1009	protected Object srcData;
	1010
	1011	SolidPixelWriter(Object srcPixel) {
	1012	this.srcData = srcPixel;
	1013	}
	1014
	1015	public void writePixel(int x, int y) {
	1016	dstRast.setDataElements(x, y, srcData);
	1017	}
	1018	}
	1019
	1020	abstract class XorPixelWriter extends PixelWriter {
	1021	protected ColorModel dstCM;
	1022
	1023	public void writePixel(int x, int y) {
	1024	Object dstPixel = dstRast.getDataElements(x, y, null);
	1025	xorPixel(dstPixel);
	1026	dstRast.setDataElements(x, y, dstPixel);
	1027	}
	1028
	1029	protected abstract void xorPixel(Object pixData);
	1030
	1031	public static class ByteData extends XorPixelWriter {
	1032	byte[] xorData;
	1033
	1034	ByteData(Object srcPixel, Object xorPixel) {
	1035	this.xorData = (byte[]) srcPixel;
	1036	xorPixel(xorPixel);
	1037	this.xorData = (byte[]) xorPixel;
	1038	}
	1039
	1040	protected void xorPixel(Object pixData) {
	1041	byte[] dstData = (byte[]) pixData;
	1042	for (int i = 0; i < dstData.length; i++) {
	1043	dstData[i] ^= xorData[i];
	1044	}
	1045	}
	1046	}
	1047
	1048	public static class ShortData extends XorPixelWriter {
	1049	short[] xorData;
	1050
	1051	ShortData(Object srcPixel, Object xorPixel) {
	1052	this.xorData = (short[]) srcPixel;
	1053	xorPixel(xorPixel);
	1054	this.xorData = (short[]) xorPixel;
	1055	}
	1056
	1057	protected void xorPixel(Object pixData) {
	1058	short[] dstData = (short[]) pixData;
	1059	for (int i = 0; i < dstData.length; i++) {
	1060	dstData[i] ^= xorData[i];
	1061	}
	1062	}
	1063	}
	1064
	1065	public static class IntData extends XorPixelWriter {
	1066	int[] xorData;
	1067
	1068	IntData(Object srcPixel, Object xorPixel) {
	1069	this.xorData = (int[]) srcPixel;
	1070	xorPixel(xorPixel);
	1071	this.xorData = (int[]) xorPixel;
	1072	}
	1073
	1074	protected void xorPixel(Object pixData) {
	1075	int[] dstData = (int[]) pixData;
	1076	for (int i = 0; i < dstData.length; i++) {
	1077	dstData[i] ^= xorData[i];
	1078	}
	1079	}
	1080	}
	1081
	1082	public static class FloatData extends XorPixelWriter {
	1083	int[] xorData;
	1084
	1085	FloatData(Object srcPixel, Object xorPixel) {
	1086	float[] srcData = (float[]) srcPixel;
	1087	float[] xorData = (float[]) xorPixel;
	1088	this.xorData = new int[srcData.length];
	1089	for (int i = 0; i < srcData.length; i++) {
	1090	this.xorData[i] = (Float.floatToIntBits(srcData[i]) ^
	1091	Float.floatToIntBits(xorData[i]));
	1092	}
	1093	}
	1094
	1095	protected void xorPixel(Object pixData) {
	1096	float[] dstData = (float[]) pixData;
	1097	for (int i = 0; i < dstData.length; i++) {
	1098	int v = Float.floatToIntBits(dstData[i]) ^ xorData[i];
	1099	dstData[i] = Float.intBitsToFloat(v);
	1100	}
	1101	}
	1102	}
	1103
	1104	public static class DoubleData extends XorPixelWriter {
	1105	long[] xorData;
	1106
	1107	DoubleData(Object srcPixel, Object xorPixel) {
	1108	double[] srcData = (double[]) srcPixel;
	1109	double[] xorData = (double[]) xorPixel;
	1110	this.xorData = new long[srcData.length];
	1111	for (int i = 0; i < srcData.length; i++) {
	1112	this.xorData[i] = (Double.doubleToLongBits(srcData[i]) ^
	1113	Double.doubleToLongBits(xorData[i]));
	1114	}
	1115	}
	1116
	1117	protected void xorPixel(Object pixData) {
	1118	double[] dstData = (double[]) pixData;
	1119	for (int i = 0; i < dstData.length; i++) {
	1120	long v = Double.doubleToLongBits(dstData[i]) ^ xorData[i];
	1121	dstData[i] = Double.longBitsToDouble(v);
	1122	}
	1123	}
	1124	}
	1125	}

java/pkg/sun/java2d/loops/GraphicsPrimitive$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitive$GeneralBinaryOp.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitive$GeneralUnaryOp.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitive$TraceReporter$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitive$TraceReporter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitive.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitive.java+623−0

@@ -0,0 +1,623 @@
	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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import java.awt.image.BufferedImage;
	33	import java.awt.AlphaComposite;
	34	import java.awt.Rectangle;
	35	import sun.awt.image.BufImgSurfaceData;
	36	import sun.java2d.SurfaceData;
	37	import sun.java2d.pipe.Region;
	38	import java.lang.reflect.Field;
	39	import java.util.StringTokenizer;
	40	import java.util.Iterator;
	41	import java.util.HashMap;
	42	import java.util.Map;
	43	import java.io.PrintStream;
	44	import java.io.OutputStream;
	45	import java.io.FileOutputStream;
	46	import java.io.FileNotFoundException;
	47	import java.security.AccessController;
	48	import java.security.PrivilegedAction;
	49	import sun.security.action.GetPropertyAction;
	50
	51	/**
	52	* defines interface for primitives which can be placed into
	53	* the graphic component manager framework
	54	*/
	55	public abstract class GraphicsPrimitive {
	56
	57	protected static interface GeneralBinaryOp {
	58	/**
	59	* This method allows the setupGeneralBinaryOp method to set
	60	* the converters into the General version of the Primitive.
	61	*/
	62	public void setPrimitives(Blit srcconverter,
	63	Blit dstconverter,
	64	GraphicsPrimitive genericop,
	65	Blit resconverter);
	66
	67	/**
	68	* These 4 methods are implemented automatically for any
	69	* GraphicsPrimitive. They are used by setupGeneralBinaryOp
	70	* to retrieve the information needed to find the right
	71	* converter primitives.
	72	*/
	73	public SurfaceType getSourceType();
	74	public CompositeType getCompositeType();
	75	public SurfaceType getDestType();
	76	public String getSignature();
	77	public int getPrimTypeID();
	78	}
	79
	80	protected static interface GeneralUnaryOp {
	81	/**
	82	* This method allows the setupGeneralUnaryOp method to set
	83	* the converters into the General version of the Primitive.
	84	*/
	85	public void setPrimitives(Blit dstconverter,
	86	GraphicsPrimitive genericop,
	87	Blit resconverter);
	88
	89	/**
	90	* These 3 methods are implemented automatically for any
	91	* GraphicsPrimitive. They are used by setupGeneralUnaryOp
	92	* to retrieve the information needed to find the right
	93	* converter primitives.
	94	*/
	95	public CompositeType getCompositeType();
	96	public SurfaceType getDestType();
	97	public String getSignature();
	98	public int getPrimTypeID();
	99	}
	100
	101	/**
	102	* INSTANCE DATA MEMBERS DESCRIBING CHARACTERISTICS OF THIS PRIMITIVE
	103	**/
	104
	105	// Making these be instance data members (instead of virtual methods
	106	// overridden by subclasses) is actually cheaper, since each class
	107	// is a singleton. As instance data members with final accessors,
	108	// accesses can be inlined.
	109	private String methodSignature;
	110	private int uniqueID;
	111	private static int unusedPrimID = 1;
	112
	113	private SurfaceType sourceType;
	114	private CompositeType compositeType;
	115	private SurfaceType destType;
	116
	117	private long pNativePrim; // Native blit loop info
	118
	119	public synchronized static final int makePrimTypeID() {
	120	if (unusedPrimID > 255) {
	121	throw new InternalError("primitive id overflow");
	122	}
	123	return unusedPrimID++;
	124	}
	125
	126	public synchronized static final int makeUniqueID(int primTypeID,
	127	SurfaceType src,
	128	CompositeType cmp,
	129	SurfaceType dst)
	130	{
	131	return (primTypeID << 24) \|
	132	(dst.getUniqueID() << 16) \|
	133	(cmp.getUniqueID() << 8) \|
	134	(src.getUniqueID());
	135	}
	136
	137	/**
	138	* Create a new GraphicsPrimitive with all of the required
	139	* descriptive information.
	140	*/
	141	protected GraphicsPrimitive(String methodSignature,
	142	int primTypeID,
	143	SurfaceType sourceType,
	144	CompositeType compositeType,
	145	SurfaceType destType)
	146	{
	147	this.methodSignature = methodSignature;
	148	this.sourceType = sourceType;
	149	this.compositeType = compositeType;
	150	this.destType = destType;
	151
	152	if(sourceType == null \|\| compositeType == null \|\| destType == null) {
	153	this.uniqueID = primTypeID << 24;
	154	} else {
	155	this.uniqueID = GraphicsPrimitive.makeUniqueID(primTypeID,
	156	sourceType,
	157	compositeType,
	158	destType);
	159	}
	160	}
	161
	162	/**
	163	* Create a new GraphicsPrimitive for native invocation
	164	* with all of the required descriptive information.
	165	*/
	166	protected GraphicsPrimitive(long pNativePrim,
	167	String methodSignature,
	168	int primTypeID,
	169	SurfaceType sourceType,
	170	CompositeType compositeType,
	171	SurfaceType destType)
	172	{
	173	this.pNativePrim = pNativePrim;
	174	this.methodSignature = methodSignature;
	175	this.sourceType = sourceType;
	176	this.compositeType = compositeType;
	177	this.destType = destType;
	178
	179	if(sourceType == null \|\| compositeType == null \|\| destType == null) {
	180	this.uniqueID = primTypeID << 24;
	181	} else {
	182	this.uniqueID = GraphicsPrimitive.makeUniqueID(primTypeID,
	183	sourceType,
	184	compositeType,
	185	destType);
	186	}
	187	}
	188
	189	/**
	190	* METHODS TO DESCRIBE THE SURFACES PRIMITIVES
	191	* CAN OPERATE ON AND THE FUNCTIONALITY THEY IMPLEMENT
	192	**/
	193
	194	/**
	195	* Gets instance ID of this graphics primitive.
	196	*
	197	* Instance ID is comprised of four distinct ids (ORed together)
	198	* that uniquely identify each instance of a GraphicsPrimitive
	199	* object. The four ids making up instance ID are:
	200	* 1. primitive id - identifier shared by all primitives of the
	201	* same type (eg. all Blits have the same primitive id)
	202	* 2. sourcetype id - identifies source surface type
	203	* 3. desttype id - identifies destination surface type
	204	* 4. compositetype id - identifies composite used
	205	*
	206	* @return instance ID
	207	*/
	208	public final int getUniqueID() {
	209	return uniqueID;
	210	}
	211
	212	/**
	213	*/
	214	public final String getSignature() {
	215	return methodSignature;
	216	}
	217
	218	/**
	219	* Gets unique id for this GraphicsPrimitive type.
	220	*
	221	* This id is used to identify the TYPE of primitive (Blit vs. BlitBg)
	222	* as opposed to INSTANCE of primitive.
	223	*
	224	* @return primitive ID
	225	*/
	226	public final int getPrimTypeID() {
	227	return uniqueID >>> 24;
	228	}
	229
	230	/**
	231	*/
	232	public final long getNativePrim() {
	233	return pNativePrim;
	234	}
	235
	236	/**
	237	*/
	238	public final SurfaceType getSourceType() {
	239	return sourceType;
	240	}
	241
	242	/**
	243	*/
	244	public final CompositeType getCompositeType() {
	245	return compositeType;
	246	}
	247
	248	/**
	249	*/
	250	public final SurfaceType getDestType() {
	251	return destType;
	252	}
	253
	254	/**
	255	* Return true if this primitive can be used for the given signature
	256	* surfaces, and composite.
	257	*
	258	* @param signature The signature of the given operation. Must be
	259	* == (not just .equals) the signature string given by the
	260	* abstract class that declares the operation.
	261	* @param srctype The surface type for the source of the operation
	262	* @param comptype The composite type for the operation
	263	* @param dsttype The surface type for the destination of the operation
	264	*/
	265	public final boolean satisfies(String signature,
	266	SurfaceType srctype,
	267	CompositeType comptype,
	268	SurfaceType dsttype)
	269	{
	270	if (signature != methodSignature) {
	271	return false;
	272	}
	273	while (true) {
	274	if (srctype == null) {
	275	return false;
	276	}
	277	if (srctype.equals(sourceType)) {
	278	break;
	279	}
	280	srctype = srctype.getSuperType();
	281	}
	282	while (true) {
	283	if (comptype == null) {
	284	return false;
	285	}
	286	if (comptype.equals(compositeType)) {
	287	break;
	288	}
	289	comptype = comptype.getSuperType();
	290	}
	291	while (true) {
	292	if (dsttype == null) {
	293	return false;
	294	}
	295	if (dsttype.equals(destType)) {
	296	break;
	297	}
	298	dsttype = dsttype.getSuperType();
	299	}
	300	return true;
	301	}
	302
	303	//
	304	// A version of satisfies used for regression testing
	305	//
	306	final boolean satisfiesSameAs(GraphicsPrimitive other) {
	307	return (methodSignature == other.methodSignature &&
	308	sourceType.equals(other.sourceType) &&
	309	compositeType.equals(other.compositeType) &&
	310	destType.equals(other.destType));
	311	}
	312
	313	public abstract GraphicsPrimitive makePrimitive(SurfaceType srctype,
	314	CompositeType comptype,
	315	SurfaceType dsttype);
	316
	317	public abstract GraphicsPrimitive traceWrap();
	318
	319	static HashMap traceMap;
	320
	321	public static int traceflags;
	322	public static String tracefile;
	323	public static PrintStream traceout;
	324
	325	public static final int TRACELOG = 1;
	326	public static final int TRACETIMESTAMP = 2;
	327	public static final int TRACECOUNTS = 4;
	328
	329	static {
	330	GetPropertyAction gpa = new GetPropertyAction("sun.java2d.trace");
	331	String trace = (String)AccessController.doPrivileged(gpa);
	332	if (trace != null) {
	333	boolean verbose = false;
	334	int traceflags = 0;
	335	StringTokenizer st = new StringTokenizer(trace, ",");
	336	while (st.hasMoreTokens()) {
	337	String tok = st.nextToken();
	338	if (tok.equalsIgnoreCase("count")) {
	339	traceflags \|= GraphicsPrimitive.TRACECOUNTS;
	340	} else if (tok.equalsIgnoreCase("log")) {
	341	traceflags \|= GraphicsPrimitive.TRACELOG;
	342	} else if (tok.equalsIgnoreCase("timestamp")) {
	343	traceflags \|= GraphicsPrimitive.TRACETIMESTAMP;
	344	} else if (tok.equalsIgnoreCase("verbose")) {
	345	verbose = true;
	346	} else if (tok.regionMatches(true, 0, "out:", 0, 4)) {
	347	tracefile = tok.substring(4);
	348	} else {
	349	if (!tok.equalsIgnoreCase("help")) {
	350	System.err.println("unrecognized token: "+tok);
	351	}
	352	System.err.println("usage: -Dsun.java2d.trace="+
	353	"[log[,timestamp]],[count],"+
	354	"[out:<filename>],[help],[verbose]");
	355	}
	356	}
	357	if (verbose) {
	358	System.err.print("GraphicsPrimitive logging ");
	359	if ((traceflags & GraphicsPrimitive.TRACELOG) != 0) {
	360	System.err.println("enabled");
	361	System.err.print("GraphicsPrimitive timetamps ");
	362	if ((traceflags & GraphicsPrimitive.TRACETIMESTAMP) != 0) {
	363	System.err.println("enabled");
	364	} else {
	365	System.err.println("disabled");
	366	}
	367	} else {
	368	System.err.println("[and timestamps] disabled");
	369	}
	370	System.err.print("GraphicsPrimitive invocation counts ");
	371	if ((traceflags & GraphicsPrimitive.TRACECOUNTS) != 0) {
	372	System.err.println("enabled");
	373	} else {
	374	System.err.println("disabled");
	375	}
	376	System.err.print("GraphicsPrimitive trace output to ");
	377	if (tracefile == null) {
	378	System.err.println("System.err");
	379	} else {
	380	System.err.println("file '"+tracefile+"'");
	381	}
	382	}
	383	GraphicsPrimitive.traceflags = traceflags;
	384	}
	385	}
	386
	387	public static boolean tracingEnabled() {
	388	return (traceflags != 0);
	389	}
	390
	391	private static PrintStream getTraceOutputFile() {
	392	if (traceout == null) {
	393	if (tracefile != null) {
	394	Object o =
	395	AccessController.doPrivileged(new PrivilegedAction() {
	396	public Object run() {
	397	try {
	398	return new FileOutputStream(tracefile);
	399	} catch (FileNotFoundException e) {
	400	return null;
	401	}
	402	}
	403	});
	404	if (o != null) {
	405	traceout = new PrintStream((OutputStream) o);
	406	} else {
	407	traceout = System.err;
	408	}
	409	} else {
	410	traceout = System.err;
	411	}
	412	}
	413	return traceout;
	414	}
	415
	416	public static class TraceReporter extends Thread {
	417	public static void setShutdownHook() {
	418	AccessController.doPrivileged(new PrivilegedAction() {
	419	public Object run() {
	420	TraceReporter t = new TraceReporter();
	421	t.setContextClassLoader(null);
	422	Runtime.getRuntime().addShutdownHook(t);
	423	return null;
	424	}
	425	});
	426	}
	427
	428	public void run() {
	429	PrintStream ps = getTraceOutputFile();
	430	Iterator iterator = traceMap.entrySet().iterator();
	431	long total = 0;
	432	int numprims = 0;
	433	while (iterator.hasNext()) {
	434	Map.Entry me = (Map.Entry) iterator.next();
	435	Object prim = me.getKey();
	436	int[] count = (int[]) me.getValue();
	437	if (count[0] == 1) {
	438	ps.print("1 call to ");
	439	} else {
	440	ps.print(count[0]+" calls to ");
	441	}
	442	ps.println(prim);
	443	numprims++;
	444	total += count[0];
	445	}
	446	if (numprims == 0) {
	447	ps.println("No graphics primitives executed");
	448	} else if (numprims > 1) {
	449	ps.println(total+" total calls to "+
	450	numprims+" different primitives");
	451	}
	452	}
	453	}
	454
	455	public synchronized static void tracePrimitive(Object prim) {
	456	if ((traceflags & TRACECOUNTS) != 0) {
	457	if (traceMap == null) {
	458	traceMap = new HashMap();
	459	TraceReporter.setShutdownHook();
	460	}
	461	Object o = traceMap.get(prim);
	462	if (o == null) {
	463	o = new int[1];
	464	traceMap.put(prim, o);
	465	}
	466	((int[]) o)[0]++;
	467	}
	468	if ((traceflags & TRACELOG) != 0) {
	469	PrintStream ps = getTraceOutputFile();
	470	if ((traceflags & TRACETIMESTAMP) != 0) {
	471	ps.print(System.currentTimeMillis()+": ");
	472	}
	473	ps.println(prim);
	474	}
	475	}
	476
	477	protected void setupGeneralBinaryOp(GeneralBinaryOp gbo) {
	478	int primID = gbo.getPrimTypeID();
	479	String methodSignature = gbo.getSignature();
	480	SurfaceType srctype = gbo.getSourceType();
	481	CompositeType comptype = gbo.getCompositeType();
	482	SurfaceType dsttype = gbo.getDestType();
	483	Blit convertsrc, convertdst, convertres;
	484	GraphicsPrimitive performop;
	485
	486	convertsrc = createConverter(srctype, SurfaceType.IntArgb);
	487	performop = GraphicsPrimitiveMgr.locatePrim(primID,
	488	SurfaceType.IntArgb,
	489	comptype, dsttype);
	490	if (performop != null) {
	491	convertdst = null;
	492	convertres = null;
	493	} else {
	494	performop = getGeneralOp(primID, comptype);
	495	if (performop == null) {
	496	throw new InternalError("Cannot construct general op for "+
	497	methodSignature+" "+comptype);
	498	}
	499	convertdst = createConverter(dsttype, SurfaceType.IntArgb);
	500	convertres = createConverter(SurfaceType.IntArgb, dsttype);
	501	}
	502
	503	gbo.setPrimitives(convertsrc, convertdst, performop, convertres);
	504	}
	505
	506	protected void setupGeneralUnaryOp(GeneralUnaryOp guo) {
	507	int primID = guo.getPrimTypeID();
	508	String methodSignature = guo.getSignature();
	509	CompositeType comptype = guo.getCompositeType();
	510	SurfaceType dsttype = guo.getDestType();
	511
	512	Blit convertdst = createConverter(dsttype, SurfaceType.IntArgb);
	513	GraphicsPrimitive performop = getGeneralOp(primID, comptype);
	514	Blit convertres = createConverter(SurfaceType.IntArgb, dsttype);
	515	if (convertdst == null \|\| performop == null \|\| convertres == null) {
	516	throw new InternalError("Cannot construct binary op for "+
	517	comptype+" "+dsttype);
	518	}
	519
	520	guo.setPrimitives(convertdst, performop, convertres);
	521	}
	522
	523	protected static Blit createConverter(SurfaceType srctype,
	524	SurfaceType dsttype)
	525	{
	526	if (srctype.equals(dsttype)) {
	527	return null;
	528	}
	529	Blit cv = Blit.getFromCache(srctype, CompositeType.SrcNoEa, dsttype);
	530	if (cv == null) {
	531	throw new InternalError("Cannot construct converter for "+
	532	srctype+"=>"+dsttype);
	533	}
	534	return cv;
	535	}
	536
	537	protected static SurfaceData convertFrom(Blit ob, SurfaceData srcData,
	538	int srcX, int srcY, int w, int h,
	539	SurfaceData dstData)
	540	{
	541	return convertFrom(ob, srcData,
	542	srcX, srcY, w, h, dstData,
	543	BufferedImage.TYPE_INT_ARGB);
	544	}
	545
	546	protected static SurfaceData convertFrom(Blit ob, SurfaceData srcData,
	547	int srcX, int srcY, int w, int h,
	548	SurfaceData dstData, int type)
	549	{
	550	if (dstData != null) {
	551	Rectangle r = dstData.getBounds();
	552	if (w > r.width \|\| h > r.height) {
	553	dstData = null;
	554	}
	555	}
	556	if (dstData == null) {
	557	BufferedImage dstBI = new BufferedImage(w, h, type);
	558	dstData = BufImgSurfaceData.createData(dstBI);
	559	}
	560	ob.Blit(srcData, dstData, AlphaComposite.Src, null,
	561	srcX, srcY, 0, 0, w, h);
	562	return dstData;
	563	}
	564
	565	protected static void convertTo(Blit ob,
	566	SurfaceData srcImg, SurfaceData dstImg,
	567	Region clip,
	568	int dstX, int dstY, int w, int h)
	569	{
	570	if (ob != null) {
	571	ob.Blit(srcImg, dstImg, AlphaComposite.Src, clip,
	572	0, 0, dstX, dstY, w, h);
	573	}
	574	}
	575
	576	protected static GraphicsPrimitive getGeneralOp(int primID,
	577	CompositeType comptype)
	578	{
	579	return GraphicsPrimitiveMgr.locatePrim(primID,
	580	SurfaceType.IntArgb,
	581	comptype,
	582	SurfaceType.IntArgb);
	583	}
	584
	585	public static String simplename(Field[] fields, Object o) {
	586	for (int i = 0; i < fields.length; i++) {
	587	Field f = fields[i];
	588	try {
	589	if (o == f.get(null)) {
	590	return f.getName();
	591	}
	592	} catch (Exception e) {
	593	}
	594	}
	595	return "\""+o.toString()+"\"";
	596	}
	597
	598	public static String simplename(SurfaceType st) {
	599	return simplename(SurfaceType.class.getDeclaredFields(), st);
	600	}
	601
	602	public static String simplename(CompositeType ct) {
	603	return simplename(CompositeType.class.getDeclaredFields(), ct);
	604	}
	605
	606	private String cachedname;
	607
	608	public String toString() {
	609	if (cachedname == null) {
	610	String sig = methodSignature;
	611	int index = sig.indexOf('(');
	612	if (index >= 0) {
	613	sig = sig.substring(0, index);
	614	}
	615	cachedname = (getClass().getName()+"::"+
	616	sig+"("+
	617	simplename(sourceType)+", "+
	618	simplename(compositeType)+", "+
	619	simplename(destType)+")");
	620	}
	621	return cachedname;
	622	}
	623	}

java/pkg/sun/java2d/loops/GraphicsPrimitiveMgr$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitiveMgr$2.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitiveMgr$PrimitiveSpec.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitiveMgr.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitiveMgr.java+330−0

@@ -0,0 +1,330 @@
	1	/*
	2	* Copyright (c) 1997, 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	/*
	27	* @author Charlton Innovations, Inc.
	28	*/
	29
	30	package sun.java2d.loops;
	31
	32	import java.util.Comparator;
	33	import java.util.Arrays;
	34	import sun.java2d.SunGraphics2D;
	35
	36	/**
	37	* GraphicsComponentMgr provides services to
	38	* 1. register primitives for later use
	39	* 2. locate an instance of a primitve based on characteristics
	40	*/
	41	public final class GraphicsPrimitiveMgr {
	42
	43	private static final boolean debugTrace = false;
	44	private static GraphicsPrimitive primitives[];
	45	private static GraphicsPrimitive generalPrimitives[];
	46	private static boolean needssort = true;
	47
	48	private static native void initIDs(Class GP, Class ST, Class CT,
	49	Class SG2D, Class Color, Class AT,
	50	Class XORComp, Class AlphaComp,
	51	Class Path2D, Class Path2DFloat,
	52	Class SHints);
	53	private static native void registerNativeLoops();
	54
	55	static {
	56	initIDs(GraphicsPrimitive.class,
	57	SurfaceType.class,
	58	CompositeType.class,
	59	SunGraphics2D.class,
	60	java.awt.Color.class,
	61	java.awt.geom.AffineTransform.class,
	62	XORComposite.class,
	63	java.awt.AlphaComposite.class,
	64	java.awt.geom.Path2D.class,
	65	java.awt.geom.Path2D.Float.class,
	66	sun.awt.SunHints.class);
	67	CustomComponent.register();
	68	GeneralRenderer.register();
	69	registerNativeLoops();
	70	}
	71
	72	private static class PrimitiveSpec {
	73	public int uniqueID;
	74	}
	75
	76	private static Comparator primSorter = new Comparator() {
	77	public int compare(Object o1, Object o2) {
	78	int id1 = ((GraphicsPrimitive) o1).getUniqueID();
	79	int id2 = ((GraphicsPrimitive) o2).getUniqueID();
	80
	81	return (id1 == id2 ? 0 : (id1 < id2 ? -1 : 1));
	82	}
	83	};
	84
	85	private static Comparator primFinder = new Comparator() {
	86	public int compare(Object o1, Object o2) {
	87	int id1 = ((GraphicsPrimitive) o1).getUniqueID();
	88	int id2 = ((PrimitiveSpec) o2).uniqueID;
	89
	90	return (id1 == id2 ? 0 : (id1 < id2 ? -1 : 1));
	91	}
	92	};
	93
	94	/**
	95	* Ensure that noone can instantiate this class.
	96	*/
	97	private GraphicsPrimitiveMgr() {
	98	}
	99
	100	public synchronized static void register(GraphicsPrimitive[] newPrimitives)
	101	{
	102	GraphicsPrimitive[] devCollection = primitives;
	103	int oldSize = 0;
	104	int newSize = newPrimitives.length;
	105	if (debugTrace) {
	106	writeLog("Registering " + newSize + " primitives");
	107	for (int i = 0; i < newSize; i++) {
	108	writeLog(newPrimitives[i].toString());
	109	}
	110	}
	111	if (devCollection != null) {
	112	oldSize = devCollection.length;
	113	}
	114	GraphicsPrimitive[] temp = new GraphicsPrimitive[oldSize + newSize];
	115	if (devCollection != null) {
	116	System.arraycopy(devCollection, 0, temp, 0, oldSize);
	117	}
	118	System.arraycopy(newPrimitives, 0, temp, oldSize, newSize);
	119	needssort = true;
	120	primitives = temp;
	121	}
	122
	123	public synchronized static void registerGeneral(GraphicsPrimitive gen) {
	124	if (generalPrimitives == null) {
	125	generalPrimitives = new GraphicsPrimitive[] {gen};
	126	return;
	127	}
	128	int len = generalPrimitives.length;
	129	GraphicsPrimitive[] newGen = new GraphicsPrimitive[len + 1];
	130	System.arraycopy(generalPrimitives, 0, newGen, 0, len);
	131	newGen[len] = gen;
	132	generalPrimitives = newGen;
	133	}
	134
	135	public synchronized static GraphicsPrimitive locate(int primTypeID,
	136	SurfaceType dsttype)
	137	{
	138	return locate(primTypeID,
	139	SurfaceType.OpaqueColor,
	140	CompositeType.Src,
	141	dsttype);
	142	}
	143
	144	public synchronized static GraphicsPrimitive locate(int primTypeID,
	145	SurfaceType srctype,
	146	CompositeType comptype,
	147	SurfaceType dsttype)
	148	{
	149	/*
	150	System.out.println("Looking for:");
	151	System.out.println(" method: "+signature);
	152	System.out.println(" from: "+srctype);
	153	System.out.println(" by: "+comptype);
	154	System.out.println(" to: "+dsttype);
	155	*/
	156	GraphicsPrimitive prim = locatePrim(primTypeID,
	157	srctype, comptype, dsttype);
	158
	159	if (prim == null) {
	160	//System.out.println("Trying general loop");
	161	prim = locateGeneral(primTypeID);
	162	if (prim != null) {
	163	prim = prim.makePrimitive(srctype, comptype, dsttype);
	164	if (prim != null && GraphicsPrimitive.traceflags != 0) {
	165	prim = prim.traceWrap();
	166	}
	167	}
	168	}
	169	return prim;
	170	}
	171
	172	public synchronized static GraphicsPrimitive
	173	locatePrim(int primTypeID,
	174	SurfaceType srctype,
	175	CompositeType comptype,
	176	SurfaceType dsttype)
	177	{
	178	/*
	179	System.out.println("Looking for:");
	180	System.out.println(" method: "+signature);
	181	System.out.println(" from: "+srctype);
	182	System.out.println(" by: "+comptype);
	183	System.out.println(" to: "+dsttype);
	184	*/
	185	SurfaceType src, dst;
	186	CompositeType cmp;
	187	GraphicsPrimitive prim;
	188	PrimitiveSpec spec = new PrimitiveSpec();
	189
	190	for (dst = dsttype; dst != null; dst = dst.getSuperType()) {
	191	for (src = srctype; src != null; src = src.getSuperType()) {
	192	for (cmp = comptype; cmp != null; cmp = cmp.getSuperType()) {
	193	/*
	194	System.out.println("Trying:");
	195	System.out.println(" method: "+spec.methodSignature);
	196	System.out.println(" from: "+spec.sourceType);
	197	System.out.println(" by: "+spec.compType);
	198	System.out.println(" to: "+spec.destType);
	199	*/
	200
	201	spec.uniqueID =
	202	GraphicsPrimitive.makeUniqueID(primTypeID, src, cmp, dst);
	203	prim = locate(spec);
	204	if (prim != null) {
	205	//System.out.println("<GPMgr> Found: " + prim + " in " + i + " steps");
	206	return prim;
	207	}
	208	}
	209	}
	210	}
	211	return null;
	212	}
	213
	214	private static GraphicsPrimitive locateGeneral(int primTypeID) {
	215	if (generalPrimitives == null) {
	216	return null;
	217	}
	218	for (int i = 0; i < generalPrimitives.length; i++) {
	219	GraphicsPrimitive prim = generalPrimitives[i];
	220	if (prim.getPrimTypeID() == primTypeID) {
	221	return prim;
	222	}
	223	}
	224	return null;
	225	//throw new InternalError("No general handler registered for"+signature);
	226	}
	227
	228	private static GraphicsPrimitive locate(PrimitiveSpec spec) {
	229	if (needssort) {
	230	if (GraphicsPrimitive.traceflags != 0) {
	231	for (int i = 0; i < primitives.length; i++) {
	232	primitives[i] = primitives[i].traceWrap();
	233	}
	234	}
	235	Arrays.sort(primitives, primSorter);
	236	needssort = false;
	237	}
	238	GraphicsPrimitive[] devCollection = primitives;
	239	if (devCollection == null) {
	240	return null;
	241	}
	242	int index = Arrays.binarySearch(devCollection, spec, primFinder);
	243	if (index >= 0) {
	244	GraphicsPrimitive prim = devCollection[index];
	245	if (prim instanceof GraphicsPrimitiveProxy) {
	246	prim = ((GraphicsPrimitiveProxy) prim).instantiate();
	247	devCollection[index] = prim;
	248	if (debugTrace) {
	249	writeLog("Instantiated graphics primitive " + prim);
	250	}
	251	}
	252	if (debugTrace) {
	253	writeLog("Lookup found[" + index + "]["+ prim + "]");
	254	}
	255	return prim;
	256	}
	257	if (debugTrace) {
	258	writeLog("Lookup found nothing for:");
	259	writeLog(" " + spec.uniqueID);
	260	}
	261	return null;
	262	}
	263
	264	private static void writeLog(String str) {
	265	if (debugTrace) {
	266	System.err.println(str);
	267	}
	268	}
	269
	270	/**
	271	* Test that all of the GraphicsPrimitiveProxy objects actually
	272	* resolve to something. Throws a RuntimeException if anything
	273	* is wrong, an has no effect if all is well.
	274	*/
	275	// This is only really meant to be called from GraphicsPrimitiveProxyTest
	276	// in the regression tests directory, but it has to be here because
	277	// it needs access to a private data structure. It is not very
	278	// big, though.
	279	public static void testPrimitiveInstantiation() {
	280	testPrimitiveInstantiation(false);
	281	}
	282
	283	public static void testPrimitiveInstantiation(boolean verbose) {
	284	int resolved = 0;
	285	int unresolved = 0;
	286	GraphicsPrimitive[] prims = primitives;
	287	for (int j = 0; j < prims.length; j++) {
	288	GraphicsPrimitive p = prims[j];
	289	if (p instanceof GraphicsPrimitiveProxy) {
	290	GraphicsPrimitive r = ((GraphicsPrimitiveProxy) p).instantiate();
	291	if (!r.getSignature().equals(p.getSignature()) \|\|
	292	r.getUniqueID() != p.getUniqueID()) {
	293	System.out.println("r.getSignature == "+r.getSignature());
	294	System.out.println("r.getUniqueID == " + r.getUniqueID());
	295	System.out.println("p.getSignature == "+p.getSignature());
	296	System.out.println("p.getUniqueID == " + p.getUniqueID());
	297	throw new RuntimeException("Primitive " + p
	298	+ " returns wrong signature for "
	299	+ r.getClass());
	300	}
	301	// instantiate checks that p.satisfiesSameAs(r)
	302	unresolved++;
	303	p = r;
	304	if (verbose) {
	305	System.out.println(p);
	306	}
	307	} else {
	308	if (verbose) {
	309	System.out.println(p + " (not proxied).");
	310	}
	311	resolved++;
	312	}
	313	}
	314	System.out.println(resolved+
	315	" graphics primitives were not proxied.");
	316	System.out.println(unresolved+
	317	" proxied graphics primitives resolved correctly.");
	318	System.out.println(resolved+unresolved+
	319	" total graphics primitives");
	320	}
	321
	322	public static void main(String argv[]) {
	323	// REMIND: Should trigger loading of platform primitives somehow...
	324	if (needssort) {
	325	Arrays.sort(primitives, primSorter);
	326	needssort = false;
	327	}
	328	testPrimitiveInstantiation(argv.length > 0);
	329	}
	330	}

java/pkg/sun/java2d/loops/GraphicsPrimitiveProxy.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/GraphicsPrimitiveProxy.java+114−0

@@ -0,0 +1,114 @@
	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	package sun.java2d.loops;
	27
	28	/**
	29	* GraphicsPrimitiveProxy
	30	*
	31	* Acts as a proxy for instances of GraphicsPrimitive, enabling lazy
	32	* classloading of these primitives. This leads to a substantial
	33	* savings in start-up time and footprint. In the typical case,
	34	* it has been found that a small number of GraphicsPrimitive instance
	35	* actually end up getting instantiated.
	36	* <p>
	37	* Note that the makePrimitive method should never be invoked on
	38	* a GraphicsPrimitiveProxy object since they are instantiated as
	39	* soon as they are found in the primitive list and never returned
	40	* to the caller.
	41	*/
	42	public class GraphicsPrimitiveProxy extends GraphicsPrimitive {
	43
	44	private Class owner;
	45	private String relativeClassName;
	46
	47	/**
	48	* Create a GraphicsPrimitiveProxy for a primitive with a no-argument
	49	* constructor.
	50	*
	51	* @param owner The owner class for this primitive. The primitive
	52	* must be in the same package as this owner.
	53	* @param relativeClassName The name of the class this is a proxy for.
	54	* This should not include the package.
	55	*/
	56	public GraphicsPrimitiveProxy(Class owner, String relativeClassName,
	57	String methodSignature,
	58	int primID,
	59	SurfaceType srctype,
	60	CompositeType comptype,
	61	SurfaceType dsttype)
	62	{
	63	super(methodSignature, primID, srctype, comptype, dsttype);
	64	this.owner = owner;
	65	this.relativeClassName = relativeClassName;
	66	}
	67
	68	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	69	CompositeType comptype,
	70	SurfaceType dsttype) {
	71	// This should never happen.
	72	throw new InternalError("makePrimitive called on a Proxy!");
	73	}
	74
	75	//
	76	// Come up with the real instance. Called from
	77	// GraphicsPrimitiveMgr.locate()
	78	//
	79	GraphicsPrimitive instantiate() {
	80	String name = getPackageName(owner.getName()) + "."
	81	+ relativeClassName;
	82	try {
	83	Class clazz = Class.forName(name);
	84	GraphicsPrimitive p = (GraphicsPrimitive) clazz.newInstance();
	85	if (!satisfiesSameAs(p)) {
	86	throw new RuntimeException("Primitive " + p
	87	+ " incompatible with proxy for "
	88	+ name);
	89	}
	90	return p;
	91	} catch (ClassNotFoundException ex) {
	92	throw new RuntimeException(ex.toString());
	93	} catch (InstantiationException ex) {
	94	throw new RuntimeException(ex.toString());
	95	} catch (IllegalAccessException ex) {
	96	throw new RuntimeException(ex.toString());
	97	}
	98	// A RuntimeException should never happen in a deployed JDK, because
	99	// the regression test GraphicsPrimitiveProxyTest will catch any
	100	// of these errors.
	101	}
	102
	103	private static String getPackageName(String className) {
	104	int lastDotIdx = className.lastIndexOf('.');
	105	if (lastDotIdx < 0) {
	106	return className;
	107	}
	108	return className.substring(0, lastDotIdx);
	109	}
	110
	111	public GraphicsPrimitive traceWrap() {
	112	return instantiate().traceWrap();
	113	}
	114	}

java/pkg/sun/java2d/loops/MaskBlit$General.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/MaskBlit$TraceMaskBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/MaskBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/MaskBlit.java+264−0

@@ -0,0 +1,264 @@
	1	/*
	2	* Copyright (c) 1999, 2004, 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.loops;
	27
	28	import java.awt.Composite;
	29	import java.lang.ref.WeakReference;
	30	import sun.java2d.loops.GraphicsPrimitive;
	31	import sun.java2d.SurfaceData;
	32	import sun.java2d.pipe.Region;
	33
	34	/**
	35	* MaskBlit
	36	* 1) copies rectangle of pixels from one surface to another
	37	* 2) performs compositing of colors based upon a Composite
	38	* parameter
	39	* 3) blends result of composite with destination using an
	40	* alpha coverage mask
	41	* 4) the mask may be null in which case it should be treated
	42	* as if it were an array of all opaque values (0xff)
	43	*
	44	* precise behavior is undefined if the source surface
	45	* and the destination surface are the same surface
	46	* with overlapping regions of pixels
	47	*/
	48
	49	public class MaskBlit extends GraphicsPrimitive
	50	{
	51	public static final String methodSignature = "MaskBlit(...)".toString();
	52
	53	public static final int primTypeID = makePrimTypeID();
	54
	55	private static RenderCache blitcache = new RenderCache(20);
	56
	57	public static MaskBlit locate(SurfaceType srctype,
	58	CompositeType comptype,
	59	SurfaceType dsttype)
	60	{
	61	return (MaskBlit)
	62	GraphicsPrimitiveMgr.locate(primTypeID,
	63	srctype, comptype, dsttype);
	64	}
	65
	66	public static MaskBlit getFromCache(SurfaceType src,
	67	CompositeType comp,
	68	SurfaceType dst)
	69	{
	70	Object o = blitcache.get(src, comp, dst);
	71	if (o != null) {
	72	return (MaskBlit) o;
	73	}
	74	MaskBlit blit = locate(src, comp, dst);
	75	if (blit == null) {
	76	System.out.println("mask blit loop not found for:");
	77	System.out.println("src: "+src);
	78	System.out.println("comp: "+comp);
	79	System.out.println("dst: "+dst);
	80	} else {
	81	blitcache.put(src, comp, dst, blit);
	82	}
	83	return blit;
	84	}
	85
	86	protected MaskBlit(SurfaceType srctype,
	87	CompositeType comptype,
	88	SurfaceType dsttype)
	89	{
	90	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	91	}
	92
	93	public MaskBlit(long pNativePrim,
	94	SurfaceType srctype,
	95	CompositeType comptype,
	96	SurfaceType dsttype)
	97	{
	98	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	99	}
	100
	101	/**
	102	* All MaskBlit implementors must have this invoker method
	103	*/
	104	public native void MaskBlit(SurfaceData src, SurfaceData dst,
	105	Composite comp, Region clip,
	106	int srcx, int srcy,
	107	int dstx, int dsty,
	108	int width, int height,
	109	byte[] mask, int maskoff, int maskscan);
	110
	111	static {
	112	GraphicsPrimitiveMgr.registerGeneral(new MaskBlit(null, null, null));
	113	}
	114
	115	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	116	CompositeType comptype,
	117	SurfaceType dsttype)
	118	{
	119	/*
	120	new Throwable().printStackTrace();
	121	System.out.println("Constructing general maskblit for:");
	122	System.out.println("src: "+srctype);
	123	System.out.println("comp: "+comptype);
	124	System.out.println("dst: "+dsttype);
	125	*/
	126
	127	if (CompositeType.Xor.equals(comptype)) {
	128	throw new InternalError("Cannot construct MaskBlit for " +
	129	"XOR mode");
	130	}
	131
	132	General ob = new General(srctype, comptype, dsttype);
	133	setupGeneralBinaryOp(ob);
	134	return ob;
	135	}
	136
	137	private static class General
	138	extends MaskBlit
	139	implements GeneralBinaryOp
	140	{
	141	Blit convertsrc;
	142	Blit convertdst;
	143	MaskBlit performop;
	144	Blit convertresult;
	145
	146	WeakReference srcTmp;
	147	WeakReference dstTmp;
	148
	149	public General(SurfaceType srctype,
	150	CompositeType comptype,
	151	SurfaceType dsttype)
	152	{
	153	super(srctype, comptype, dsttype);
	154	}
	155
	156	public void setPrimitives(Blit srcconverter,
	157	Blit dstconverter,
	158	GraphicsPrimitive genericop,
	159	Blit resconverter)
	160	{
	161	this.convertsrc = srcconverter;
	162	this.convertdst = dstconverter;
	163	this.performop = (MaskBlit) genericop;
	164	this.convertresult = resconverter;
	165	}
	166
	167	public synchronized void MaskBlit(SurfaceData srcData,
	168	SurfaceData dstData,
	169	Composite comp,
	170	Region clip,
	171	int srcx, int srcy,
	172	int dstx, int dsty,
	173	int width, int height,
	174	byte mask[], int offset, int scan)
	175	{
	176	SurfaceData src, dst;
	177	Region opclip;
	178	int sx, sy, dx, dy;
	179
	180	if (convertsrc == null) {
	181	src = srcData;
	182	sx = srcx;
	183	sy = srcy;
	184	} else {
	185	SurfaceData cachedSrc = null;
	186	if (srcTmp != null) {
	187	cachedSrc = (SurfaceData) srcTmp.get();
	188	}
	189	src = convertFrom(convertsrc, srcData, srcx, srcy,
	190	width, height, cachedSrc);
	191	sx = 0;
	192	sy = 0;
	193	if (src != cachedSrc) {
	194	srcTmp = new WeakReference(src);
	195	}
	196	}
	197
	198	if (convertdst == null) {
	199	dst = dstData;
	200	dx = dstx;
	201	dy = dsty;
	202	opclip = clip;
	203	} else {
	204	// assert: convertresult != null
	205	SurfaceData cachedDst = null;
	206	if (dstTmp != null) {
	207	cachedDst = (SurfaceData) dstTmp.get();
	208	}
	209	dst = convertFrom(convertdst, dstData, dstx, dsty,
	210	width, height, cachedDst);
	211	dx = 0;
	212	dy = 0;
	213	opclip = null;
	214	if (dst != cachedDst) {
	215	dstTmp = new WeakReference(dst);
	216	}
	217	}
	218
	219	performop.MaskBlit(src, dst, comp, opclip,
	220	sx, sy, dx, dy, width, height,
	221	mask, offset, scan);
	222
	223	if (convertresult != null) {
	224	// assert: convertdst != null
	225	convertTo(convertresult, dst, dstData, clip,
	226	dstx, dsty, width, height);
	227	}
	228	}
	229	}
	230
	231	public GraphicsPrimitive traceWrap() {
	232	return new TraceMaskBlit(this);
	233	}
	234
	235	private static class TraceMaskBlit extends MaskBlit {
	236	MaskBlit target;
	237
	238	public TraceMaskBlit(MaskBlit target) {
	239	// We need to have the same NativePrim as our
	240	// target in case we are used with a TransformHelper
	241	super(target.getNativePrim(),
	242	target.getSourceType(),
	243	target.getCompositeType(),
	244	target.getDestType());
	245	this.target = target;
	246	}
	247
	248	public GraphicsPrimitive traceWrap() {
	249	return this;
	250	}
	251
	252	public void MaskBlit(SurfaceData src, SurfaceData dst,
	253	Composite comp, Region clip,
	254	int srcx, int srcy, int dstx, int dsty,
	255	int width, int height,
	256	byte[] mask, int maskoff, int maskscan)
	257	{
	258	tracePrimitive(target);
	259	target.MaskBlit(src, dst, comp, clip,
	260	srcx, srcy, dstx, dsty, width, height,
	261	mask, maskoff, maskscan);
	262	}
	263	}
	264	}

java/pkg/sun/java2d/loops/MaskFill$General.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/MaskFill$TraceMaskFill.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/MaskFill.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/MaskFill.java+273−0

@@ -0,0 +1,273 @@
	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.loops;
	27
	28	import java.awt.Paint;
	29	import java.awt.PaintContext;
	30	import java.awt.Composite;
	31	import java.awt.Rectangle;
	32	import java.awt.image.ColorModel;
	33	import java.awt.image.BufferedImage;
	34	import java.awt.image.WritableRaster;
	35	import sun.awt.image.BufImgSurfaceData;
	36	import sun.java2d.loops.GraphicsPrimitive;
	37	import sun.java2d.SunGraphics2D;
	38	import sun.java2d.SurfaceData;
	39
	40	/**
	41	* MaskFill
	42	* 1) fills rectangles of pixels on a surface
	43	* 2) performs compositing of colors based upon a Composite
	44	* parameter
	45	* 3) blends result of composite with destination using an
	46	* alpha coverage mask
	47	* 4) the mask may be null in which case it should be treated
	48	* as if it were an array of all opaque values (0xff)
	49	*/
	50	public class MaskFill extends GraphicsPrimitive
	51	{
	52	public static final String methodSignature = "MaskFill(...)".toString();
	53	public static final String fillPgramSignature =
	54	"FillAAPgram(...)".toString();
	55	public static final String drawPgramSignature =
	56	"DrawAAPgram(...)".toString();
	57
	58	public static final int primTypeID = makePrimTypeID();
	59
	60	private static RenderCache fillcache = new RenderCache(10);
	61
	62	public static MaskFill locate(SurfaceType srctype,
	63	CompositeType comptype,
	64	SurfaceType dsttype)
	65	{
	66	return (MaskFill)
	67	GraphicsPrimitiveMgr.locate(primTypeID,
	68	srctype, comptype, dsttype);
	69	}
	70
	71	public static MaskFill locatePrim(SurfaceType srctype,
	72	CompositeType comptype,
	73	SurfaceType dsttype)
	74	{
	75	return (MaskFill)
	76	GraphicsPrimitiveMgr.locatePrim(primTypeID,
	77	srctype, comptype, dsttype);
	78	}
	79
	80	/*
	81	* Note that this uses locatePrim, not locate, so it can return
	82	* null if there is no specific loop to handle this op...
	83	*/
	84	public static MaskFill getFromCache(SurfaceType src,
	85	CompositeType comp,
	86	SurfaceType dst)
	87	{
	88	Object o = fillcache.get(src, comp, dst);
	89	if (o != null) {
	90	return (MaskFill) o;
	91	}
	92	MaskFill fill = locatePrim(src, comp, dst);
	93	if (fill != null) {
	94	fillcache.put(src, comp, dst, fill);
	95	}
	96	return fill;
	97	}
	98
	99	protected MaskFill(String alternateSignature,
	100	SurfaceType srctype,
	101	CompositeType comptype,
	102	SurfaceType dsttype)
	103	{
	104	super(alternateSignature, primTypeID, srctype, comptype, dsttype);
	105	}
	106
	107	protected MaskFill(SurfaceType srctype,
	108	CompositeType comptype,
	109	SurfaceType dsttype)
	110	{
	111	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	112	}
	113
	114	public MaskFill(long pNativePrim,
	115	SurfaceType srctype,
	116	CompositeType comptype,
	117	SurfaceType dsttype)
	118	{
	119	super(pNativePrim, methodSignature, primTypeID, srctype, comptype, dsttype);
	120	}
	121
	122	/**
	123	* All MaskFill implementors must have this invoker method
	124	*/
	125	public native void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
	126	Composite comp,
	127	int x, int y, int w, int h,
	128	byte[] mask, int maskoff, int maskscan);
	129
	130	public native void FillAAPgram(SunGraphics2D sg2d, SurfaceData sData,
	131	Composite comp,
	132	double x, double y,
	133	double dx1, double dy1,
	134	double dx2, double dy2);
	135
	136	public native void DrawAAPgram(SunGraphics2D sg2d, SurfaceData sData,
	137	Composite comp,
	138	double x, double y,
	139	double dx1, double dy1,
	140	double dx2, double dy2,
	141	double lw1, double lw2);
	142
	143	public boolean canDoParallelograms() {
	144	return (getNativePrim() != 0);
	145	}
	146
	147	static {
	148	GraphicsPrimitiveMgr.registerGeneral(new MaskFill(null, null, null));
	149	}
	150
	151	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	152	CompositeType comptype,
	153	SurfaceType dsttype)
	154	{
	155	if (SurfaceType.OpaqueColor.equals(srctype) \|\|
	156	SurfaceType.AnyColor.equals(srctype))
	157	{
	158	if (CompositeType.Xor.equals(comptype)) {
	159	throw new InternalError("Cannot construct MaskFill for " +
	160	"XOR mode");
	161	} else {
	162	return new General(srctype, comptype, dsttype);
	163	}
	164	} else {
	165	throw new InternalError("MaskFill can only fill with colors");
	166	}
	167	}
	168
	169	private static class General extends MaskFill {
	170	FillRect fillop;
	171	MaskBlit maskop;
	172
	173	public General(SurfaceType srctype,
	174	CompositeType comptype,
	175	SurfaceType dsttype)
	176	{
	177	super(srctype, comptype, dsttype);
	178	fillop = FillRect.locate(srctype,
	179	CompositeType.SrcNoEa,
	180	SurfaceType.IntArgb);
	181	maskop = MaskBlit.locate(SurfaceType.IntArgb, comptype, dsttype);
	182	}
	183
	184	public void MaskFill(SunGraphics2D sg2d,
	185	SurfaceData sData,
	186	Composite comp,
	187	int x, int y, int w, int h,
	188	byte mask[], int offset, int scan)
	189	{
	190	BufferedImage dstBI =
	191	new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
	192	SurfaceData tmpData = BufImgSurfaceData.createData(dstBI);
	193
	194	// REMIND: This is not pretty. It would be nicer if we
	195	// passed a "FillData" object to the Pixel loops, instead
	196	// of a SunGraphics2D parameter...
	197	int pixel = sg2d.pixel;
	198	sg2d.pixel = tmpData.pixelFor(sg2d.getColor());
	199	fillop.FillRect(sg2d, tmpData, 0, 0, w, h);
	200	sg2d.pixel = pixel;
	201
	202	maskop.MaskBlit(tmpData, sData, comp, null,
	203	0, 0, x, y, w, h,
	204	mask, offset, scan);
	205	}
	206	}
	207
	208	public GraphicsPrimitive traceWrap() {
	209	return new TraceMaskFill(this);
	210	}
	211
	212	private static class TraceMaskFill extends MaskFill {
	213	MaskFill target;
	214	MaskFill fillPgramTarget;
	215	MaskFill drawPgramTarget;
	216
	217	public TraceMaskFill(MaskFill target) {
	218	super(target.getSourceType(),
	219	target.getCompositeType(),
	220	target.getDestType());
	221	this.target = target;
	222	this.fillPgramTarget = new MaskFill(fillPgramSignature,
	223	target.getSourceType(),
	224	target.getCompositeType(),
	225	target.getDestType());
	226	this.drawPgramTarget = new MaskFill(drawPgramSignature,
	227	target.getSourceType(),
	228	target.getCompositeType(),
	229	target.getDestType());
	230	}
	231
	232	public GraphicsPrimitive traceWrap() {
	233	return this;
	234	}
	235
	236	public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
	237	Composite comp,
	238	int x, int y, int w, int h,
	239	byte[] mask, int maskoff, int maskscan)
	240	{
	241	tracePrimitive(target);
	242	target.MaskFill(sg2d, sData, comp, x, y, w, h,
	243	mask, maskoff, maskscan);
	244	}
	245
	246	public void FillAAPgram(SunGraphics2D sg2d, SurfaceData sData,
	247	Composite comp,
	248	double x, double y,
	249	double dx1, double dy1,
	250	double dx2, double dy2)
	251	{
	252	tracePrimitive(fillPgramTarget);
	253	target.FillAAPgram(sg2d, sData, comp,
	254	x, y, dx1, dy1, dx2, dy2);
	255	}
	256
	257	public void DrawAAPgram(SunGraphics2D sg2d, SurfaceData sData,
	258	Composite comp,
	259	double x, double y,
	260	double dx1, double dy1,
	261	double dx2, double dy2,
	262	double lw1, double lw2)
	263	{
	264	tracePrimitive(drawPgramTarget);
	265	target.DrawAAPgram(sg2d, sData, comp,
	266	x, y, dx1, dy1, dx2, dy2, lw1, lw2);
	267	}
	268
	269	public boolean canDoParallelograms() {
	270	return target.canDoParallelograms();
	271	}
	272	}
	273	}

java/pkg/sun/java2d/loops/OpaqueCopyAnyToArgb.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/OpaqueCopyArgbToAny.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/PixelWriter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/PixelWriterDrawHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$1.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$ActiveEdgeList.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$DrawHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$DrawProcessHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$Edge.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$EndSubPathHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$FillData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$FillProcessHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$Point.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath$ProcessHandler.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ProcessPath.java+2128−0

@@ -0,0 +1,2128 @@
	1	/*
	2	* Copyright (c) 2005, 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.loops;
	27
	28	import java.awt.geom.Path2D;
	29	import java.awt.geom.PathIterator;
	30	import java.awt.geom.QuadCurve2D;
	31	import sun.awt.SunHints;
	32	import java.util.*;
	33
	34	/* This is the java implementation of the native code from
	35	* src/share/native/sun/java2d/loops/ProcessPath.[c,h]
	36	* This code is written to be as much similar to the native
	37	* as it possible. So, it sometimes does not follow java naming conventions.
	38	*
	39	* It's important to keep this code synchronized with native one. See more
	40	* comments, description and high level scheme of the rendering process in the
	41	* ProcessPath.c
	42	*/
	43
	44	public class ProcessPath {
	45
	46	/* Public interfaces and methods for drawing and filling general paths */
	47
	48	public static abstract class DrawHandler {
	49	public int xMin;
	50	public int yMin;
	51	public int xMax;
	52	public int yMax;
	53	public float xMinf;
	54	public float yMinf;
	55	public float xMaxf;
	56	public float yMaxf;
	57
	58	public int strokeControl;
	59
	60	public DrawHandler(int xMin, int yMin, int xMax, int yMax,
	61	int strokeControl)
	62	{
	63	setBounds(xMin, yMin, xMax, yMax, strokeControl);
	64	}
	65
	66	public void setBounds(int xMin, int yMin, int xMax, int yMax)
	67	{
	68	this.xMin = xMin;
	69	this.yMin = yMin;
	70	this.xMax = xMax;
	71	this.yMax = yMax;
	72
	73	/* Setting up fractional clipping box
	74	*
	75	* We are using following float -> int mapping:
	76	*
	77	* xi = floor(xf + 0.5)
	78	*
	79	* So, fractional values that hit the [xmin, xmax) integer interval
	80	* will be situated inside the [xmin-0.5, xmax - 0.5) fractional
	81	* interval. We are using EPSF constant to provide that upper
	82	* boundary is not included.
	83	*/
	84	xMinf = xMin - 0.5f;
	85	yMinf = yMin - 0.5f;
	86	xMaxf = xMax - 0.5f - EPSF;
	87	yMaxf = yMax - 0.5f - EPSF;
	88	}
	89
	90	public void setBounds(int xMin, int yMin, int xMax, int yMax,
	91	int strokeControl)
	92	{
	93	this.strokeControl = strokeControl;
	94	setBounds(xMin, yMin, xMax, yMax);
	95	}
	96
	97	public void adjustBounds(int bxMin, int byMin, int bxMax, int byMax)
	98	{
	99	if (xMin > bxMin) bxMin = xMin;
	100	if (xMax < bxMax) bxMax = xMax;
	101	if (yMin > byMin) byMin = yMin;
	102	if (yMax < byMax) byMax = yMax;
	103	setBounds(bxMin, byMin, bxMax, byMax);
	104	}
	105
	106	public DrawHandler(int xMin, int yMin, int xMax, int yMax) {
	107	this(xMin, yMin, xMax, yMax, SunHints.INTVAL_STROKE_DEFAULT);
	108	}
	109
	110	public abstract void drawLine(int x0, int y0, int x1, int y1);
	111
	112	public abstract void drawPixel(int x0, int y0);
	113
	114	public abstract void drawScanline(int x0, int x1, int y0);
	115	}
	116
	117	public interface EndSubPathHandler {
	118	public void processEndSubPath();
	119	}
	120
	121	public static final int PH_MODE_DRAW_CLIP = 0;
	122	public static final int PH_MODE_FILL_CLIP = 1;
	123
	124	public static abstract class ProcessHandler implements EndSubPathHandler {
	125	DrawHandler dhnd;
	126	int clipMode;
	127
	128	public ProcessHandler(DrawHandler dhnd,
	129	int clipMode) {
	130	this.dhnd = dhnd;
	131	this.clipMode = clipMode;
	132	}
	133
	134	public abstract void processFixedLine(int x1, int y1,
	135	int x2, int y2, int [] pixelInfo,
	136	boolean checkBounds,
	137	boolean endSubPath);
	138	}
	139
	140	public static EndSubPathHandler noopEndSubPathHandler =
	141	new EndSubPathHandler() {
	142	public void processEndSubPath() { }
	143	};
	144
	145	public static boolean fillPath(DrawHandler dhnd, Path2D.Float p2df,
	146	int transX, int transY)
	147	{
	148	FillProcessHandler fhnd = new FillProcessHandler(dhnd);
	149	if (!doProcessPath(fhnd, p2df, transX, transY)) {
	150	return false;
	151	}
	152	FillPolygon(fhnd, p2df.getWindingRule());
	153	return true;
	154	}
	155
	156	public static boolean drawPath(DrawHandler dhnd,
	157	EndSubPathHandler endSubPath,
	158	Path2D.Float p2df,
	159	int transX, int transY)
	160	{
	161	return doProcessPath(new DrawProcessHandler(dhnd, endSubPath),
	162	p2df, transX, transY);
	163	}
	164
	165	public static boolean drawPath(DrawHandler dhnd,
	166	Path2D.Float p2df,
	167	int transX, int transY)
	168	{
	169	return doProcessPath(new DrawProcessHandler(dhnd,
	170	noopEndSubPathHandler),
	171	p2df, transX, transY);
	172	}
	173
	174	/* Private implementation of the rendering process */
	175
	176	/* Boundaries used for skipping huge path segments */
	177	private static final float UPPER_BND = Float.MAX_VALUE/4.0f;
	178	private static final float LOWER_BND = -UPPER_BND;
	179
	180	/* Precision (in bits) used in forward differencing */
	181	private static final int FWD_PREC = 7;
	182
	183	/* Precision (in bits) used for the rounding in the midpoint test */
	184	private static final int MDP_PREC = 10;
	185
	186	private static final int MDP_MULT = 1 << MDP_PREC;
	187	private static final int MDP_HALF_MULT = MDP_MULT >> 1;
	188
	189	/* Boundaries used for clipping large path segments (those are inside
	190	* [UPPER/LOWER]_BND boundaries)
	191	*/
	192	private static final int UPPER_OUT_BND = 1 << (30 - MDP_PREC);
	193	private static final int LOWER_OUT_BND = -UPPER_OUT_BND;
	194
	195
	196	/* Calculation boundaries. They are used for switching to the more slow but
	197	* allowing larger input values method of calculation of the initial values
	198	* of the scan converted line segments inside the FillPolygon
	199	*/
	200	private static final float CALC_UBND = 1 << (30 - MDP_PREC);
	201	private static final float CALC_LBND = -CALC_UBND;
	202
	203
	204	/* Following constants are used for providing open boundaries of the
	205	* intervals
	206	*/
	207	public static final int EPSFX = 1;
	208	public static final float EPSF = ((float)EPSFX)/MDP_MULT;
	209
	210	/* Bit mask used to separate whole part from the fraction part of the
	211	* number
	212	*/
	213	private static final int MDP_W_MASK = -MDP_MULT;
	214
	215	/* Bit mask used to separate fractional part from the whole part of the
	216	* number
	217	*/
	218	private static final int MDP_F_MASK = MDP_MULT - 1;
	219
	220	/*
	221	* Constants for the forward differencing
	222	* of the cubic and quad curves
	223	*/
	224
	225	/* Maximum size of the cubic curve (calculated as the size of the bounding
	226	* box of the control points) which could be rendered without splitting
	227	*/
	228	private static final int MAX_CUB_SIZE = 256;
	229
	230	/* Maximum size of the quad curve (calculated as the size of the bounding
	231	* box of the control points) which could be rendered without splitting
	232	*/
	233	private static final int MAX_QUAD_SIZE = 1024;
	234
	235	/* Default power of 2 steps used in the forward differencing. Here DF prefix
	236	* stands for DeFault. Constants below are used as initial values for the
	237	* adaptive forward differencing algorithm.
	238	*/
	239	private static final int DF_CUB_STEPS = 3;
	240	private static final int DF_QUAD_STEPS = 2;
	241
	242	/* Shift of the current point of the curve for preparing to the midpoint
	243	* rounding
	244	*/
	245	private static final int DF_CUB_SHIFT = FWD_PREC + DF_CUB_STEPS*3 -
	246	MDP_PREC;
	247	private static final int DF_QUAD_SHIFT = FWD_PREC + DF_QUAD_STEPS*2 -
	248	MDP_PREC;
	249
	250	/* Default amount of steps of the forward differencing */
	251	private static final int DF_CUB_COUNT = (1<<DF_CUB_STEPS);
	252	private static final int DF_QUAD_COUNT = (1<<DF_QUAD_STEPS);
	253
	254	/* Default boundary constants used to check the necessity of the restepping
	255	*/
	256	private static final int DF_CUB_DEC_BND = 1<<DF_CUB_STEPS*3 + FWD_PREC + 2;
	257	private static final int DF_CUB_INC_BND = 1<<DF_CUB_STEPS*3 + FWD_PREC - 1;
	258	private static final int DF_QUAD_DEC_BND = 1<<DF_QUAD_STEPS*2 +
	259	FWD_PREC + 2;
	260	private static final int DF_QUAD_INC_BND = 1<<DF_QUAD_STEPS*2 +
	261	FWD_PREC - 1;
	262
	263	/* Multipliers for the coefficients of the polynomial form of the cubic and
	264	* quad curves representation
	265	*/
	266	private static final int CUB_A_SHIFT = FWD_PREC;
	267	private static final int CUB_B_SHIFT = (DF_CUB_STEPS + FWD_PREC + 1);
	268	private static final int CUB_C_SHIFT = (DF_CUB_STEPS*2 + FWD_PREC);
	269
	270	private static final int CUB_A_MDP_MULT = (1<<CUB_A_SHIFT);
	271	private static final int CUB_B_MDP_MULT = (1<<CUB_B_SHIFT);
	272	private static final int CUB_C_MDP_MULT = (1<<CUB_C_SHIFT);
	273
	274	private static final int QUAD_A_SHIFT = FWD_PREC;
	275	private static final int QUAD_B_SHIFT = (DF_QUAD_STEPS + FWD_PREC);
	276
	277	private static final int QUAD_A_MDP_MULT = (1<<QUAD_A_SHIFT);
	278	private static final int QUAD_B_MDP_MULT = (1<<QUAD_B_SHIFT);
	279
	280	/* Clipping macros for drawing and filling algorithms */
	281	private static float CLIP(float a1, float b1, float a2, float b2,
	282	double t) {
	283	return (float)(b1 + (double)(t - a1)*(b2 - b1) / (a2 - a1));
	284	}
	285
	286	private static int CLIP(int a1, int b1, int a2, int b2, double t) {
	287	return (int)(b1 + (double)(t - a1)*(b2 - b1) / (a2 - a1));
	288	}
	289
	290
	291	private static final int CRES_MIN_CLIPPED = 0;
	292	private static final int CRES_MAX_CLIPPED = 1;
	293	private static final int CRES_NOT_CLIPPED = 3;
	294	private static final int CRES_INVISIBLE = 4;
	295
	296	private static boolean IS_CLIPPED(int res) {
	297	return res == CRES_MIN_CLIPPED \|\| res == CRES_MAX_CLIPPED;
	298	}
	299
	300	/* This is java implementation of the macro from ProcessGeneralPath.c.
	301	* To keep the logic of the java code similar to the native one
	302	* array and set of indexes are used to point out the data.
	303	*/
	304	private static int TESTANDCLIP(float LINE_MIN, float LINE_MAX, float[] c,
	305	int a1, int b1, int a2, int b2) {
	306	double t;
	307	int res = CRES_NOT_CLIPPED;
	308	if (c[a1] < (LINE_MIN) \|\| c[a1] > (LINE_MAX)) {
	309	if (c[a1] < (LINE_MIN)) {
	310	if (c[a2] < (LINE_MIN)) {
	311	return CRES_INVISIBLE;
	312	};
	313	res = CRES_MIN_CLIPPED;
	314	t = (LINE_MIN);
	315	} else {
	316	if (c[a2] > (LINE_MAX)) {
	317	return CRES_INVISIBLE;
	318	};
	319	res = CRES_MAX_CLIPPED;
	320	t = (LINE_MAX);
	321	}
	322	c[b1] = CLIP(c[a1], c[b1], c[a2], c[b2], t);
	323	c[a1] = (float)t;
	324	}
	325	return res;
	326	}
	327
	328	/* Integer version of the method above */
	329	private static int TESTANDCLIP(int LINE_MIN, int LINE_MAX, int[] c,
	330	int a1, int b1, int a2, int b2) {
	331	double t;
	332	int res = CRES_NOT_CLIPPED;
	333	if (c[a1] < (LINE_MIN) \|\| c[a1] > (LINE_MAX)) {
	334	if (c[a1] < (LINE_MIN)) {
	335	if (c[a2] < (LINE_MIN)) {
	336	return CRES_INVISIBLE;
	337	};
	338	res = CRES_MIN_CLIPPED;
	339	t = (LINE_MIN);
	340	} else {
	341	if (c[a2] > (LINE_MAX)) {
	342	return CRES_INVISIBLE;
	343	};
	344	res = CRES_MAX_CLIPPED;
	345	t = (LINE_MAX);
	346	}
	347	c[b1] = CLIP(c[a1], c[b1], c[a2], c[b2], t);
	348	c[a1] = (int)t;
	349	}
	350	return res;
	351	}
	352
	353
	354
	355	/* Following method is used for clipping and clumping filled shapes.
	356	* An example of this process is shown on the picture below:
	357	* ----+ ----+
	358	* \|/ \| \|/ \|
	359	* + \| + \|
	360	* /\| \| I \|
	361	* / \| \| I \|
	362	* \| \| \| ===> I \|
	363	* \ \| \| I \|
	364	* \\| \| I \|
	365	* + \| + \|
	366	* \|\ \| \|\ \|
	367	* \| ----+ \| ----+
	368	* boundary boundary
	369	*
	370	* We can only perform clipping in case of right side of the output area
	371	* because all segments passed out the right boundary don't influence on the
	372	* result of scan conversion algorithm (it correctly handles half open
	373	* contours).
	374	*
	375	* This is java implementation of the macro from ProcessGeneralPath.c.
	376	* To keep the logic of the java code similar to the native one
	377	* array and set of indexes are used to point out the data.
	378	*
	379	*/
	380	private static int CLIPCLAMP(float LINE_MIN, float LINE_MAX, float[] c,
	381	int a1, int b1, int a2, int b2,
	382	int a3, int b3) {
	383	c[a3] = c[a1];
	384	c[b3] = c[b1];
	385	int res = TESTANDCLIP(LINE_MIN, LINE_MAX, c, a1, b1, a2, b2);
	386	if (res == CRES_MIN_CLIPPED) {
	387	c[a3] = c[a1];
	388	} else if (res == CRES_MAX_CLIPPED) {
	389	c[a3] = c[a1];
	390	res = CRES_MAX_CLIPPED;
	391	} else if (res == CRES_INVISIBLE) {
	392	if (c[a1] > LINE_MAX) {
	393	res = CRES_INVISIBLE;
	394	} else {
	395	c[a1] = LINE_MIN;
	396	c[a2] = LINE_MIN;
	397	res = CRES_NOT_CLIPPED;
	398	}
	399	}
	400	return res;
	401	}
	402
	403	/* Integer version of the method above */
	404	private static int CLIPCLAMP(int LINE_MIN, int LINE_MAX, int[] c,
	405	int a1, int b1, int a2, int b2,
	406	int a3, int b3) {
	407	c[a3] = c[a1];
	408	c[b3] = c[b1];
	409	int res = TESTANDCLIP(LINE_MIN, LINE_MAX, c, a1, b1, a2, b2);
	410	if (res == CRES_MIN_CLIPPED) {
	411	c[a3] = c[a1];
	412	} else if (res == CRES_MAX_CLIPPED) {
	413	c[a3] = c[a1];
	414	res = CRES_MAX_CLIPPED;
	415	} else if (res == CRES_INVISIBLE) {
	416	if (c[a1] > LINE_MAX) {
	417	res = CRES_INVISIBLE;
	418	} else {
	419	c[a1] = LINE_MIN;
	420	c[a2] = LINE_MIN;
	421	res = CRES_NOT_CLIPPED;
	422	}
	423	}
	424	return res;
	425	}
	426
	427	private static class DrawProcessHandler extends ProcessHandler {
	428
	429	EndSubPathHandler processESP;
	430
	431	public DrawProcessHandler(DrawHandler dhnd,
	432	EndSubPathHandler processESP) {
	433	super(dhnd, PH_MODE_DRAW_CLIP);
	434	this.dhnd = dhnd;
	435	this.processESP = processESP;
	436	}
	437
	438	public void processEndSubPath() {
	439	processESP.processEndSubPath();
	440	}
	441
	442	void PROCESS_LINE(int fX0, int fY0, int fX1, int fY1,
	443	boolean checkBounds, int[] pixelInfo) {
	444	int X0 = fX0 >> MDP_PREC;
	445	int Y0 = fY0 >> MDP_PREC;
	446	int X1 = fX1 >> MDP_PREC;
	447	int Y1 = fY1 >> MDP_PREC;
	448
	449	/* Handling lines having just one pixel */
	450	if (((X0^X1) \| (Y0^Y1)) == 0) {
	451	if (checkBounds &&
	452	(dhnd.yMin > Y0 \|\|
	453	dhnd.yMax <= Y0 \|\|
	454	dhnd.xMin > X0 \|\|
	455	dhnd.xMax <= X0)) return;
	456
	457	if (pixelInfo[0] == 0) {
	458	pixelInfo[0] = 1;
	459	pixelInfo[1] = X0;
	460	pixelInfo[2] = Y0;
	461	pixelInfo[3] = X0;
	462	pixelInfo[4] = Y0;
	463	dhnd.drawPixel(X0, Y0);
	464	} else if ((X0 != pixelInfo[3] \|\| Y0 != pixelInfo[4]) &&
	465	(X0 != pixelInfo[1] \|\| Y0 != pixelInfo[2])) {
	466	dhnd.drawPixel(X0, Y0);
	467	pixelInfo[3] = X0;
	468	pixelInfo[4] = Y0;
	469	}
	470	return;
	471	}
	472
	473	if (!checkBounds \|\|
	474	(dhnd.yMin <= Y0 &&
	475	dhnd.yMax > Y0 &&
	476	dhnd.xMin <= X0 &&
	477	dhnd.xMax > X0))
	478	{
	479	/* Switch off first pixel of the line before drawing */
	480	if (pixelInfo[0] == 1 &&
	481	((pixelInfo[1] == X0 && pixelInfo[2] == Y0) \|\|
	482	(pixelInfo[3] == X0 && pixelInfo[4] == Y0)))
	483	{
	484	dhnd.drawPixel(X0, Y0);
	485	}
	486	}
	487
	488	dhnd.drawLine(X0, Y0, X1, Y1);
	489
	490	if (pixelInfo[0] == 0) {
	491	pixelInfo[0] = 1;
	492	pixelInfo[1] = X0;
	493	pixelInfo[2] = Y0;
	494	pixelInfo[3] = X0;
	495	pixelInfo[4] = Y0;
	496	}
	497
	498	/* Switch on last pixel of the line if it was already
	499	* drawn during rendering of the previous segments
	500	*/
	501	if ((pixelInfo[1] == X1 && pixelInfo[2] == Y1) \|\|
	502	(pixelInfo[3] == X1 && pixelInfo[4] == Y1))
	503	{
	504	if (checkBounds &&
	505	(dhnd.yMin > Y1 \|\|
	506	dhnd.yMax <= Y1 \|\|
	507	dhnd.xMin > X1 \|\|
	508	dhnd.xMax <= X1)) {
	509	return;
	510	}
	511
	512	dhnd.drawPixel(X1, Y1);
	513	}
	514	pixelInfo[3] = X1;
	515	pixelInfo[4] = Y1;
	516	}
	517
	518	void PROCESS_POINT(int fX, int fY, boolean checkBounds,
	519	int[] pixelInfo) {
	520	int _X = fX>> MDP_PREC;
	521	int _Y = fY>> MDP_PREC;
	522	if (checkBounds &&
	523	(dhnd.yMin > _Y \|\|
	524	dhnd.yMax <= _Y \|\|
	525	dhnd.xMin > _X \|\|
	526	dhnd.xMax <= _X)) return;
	527	/*
	528	* (_X,_Y) should be inside boundaries
	529	*
	530	* assert(dhnd.yMin <= _Y &&
	531	* dhnd.yMax > _Y &&
	532	* dhnd.xMin <= _X &&
	533	* dhnd.xMax > _X);
	534	*
	535	*/
	536	if (pixelInfo[0] == 0) {
	537	pixelInfo[0] = 1;
	538	pixelInfo[1] = _X;
	539	pixelInfo[2] = _Y;
	540	pixelInfo[3] = _X;
	541	pixelInfo[4] = _Y;
	542	dhnd.drawPixel(_X, _Y);
	543	} else if ((_X != pixelInfo[3] \|\| _Y != pixelInfo[4]) &&
	544	(_X != pixelInfo[1] \|\| _Y != pixelInfo[2])) {
	545	dhnd.drawPixel(_X, _Y);
	546	pixelInfo[3] = _X;
	547	pixelInfo[4] = _Y;
	548	}
	549	}
	550
	551	/* Drawing line with subpixel endpoints
	552	*
	553	* (x1, y1), (x2, y2) - fixed point coordinates of the endpoints
	554	* with MDP_PREC bits for the fractional part
	555	*
	556	* pixelInfo - structure which keeps drawing info for avoiding
	557	* multiple drawing at the same position on the
	558	* screen (required for the XOR mode of drawing)
	559	*
	560	* pixelInfo[0] - state of the drawing
	561	* 0 - no pixel drawn between
	562	* moveTo/close of the path
	563	* 1 - there are drawn pixels
	564	*
	565	* pixelInfo[1,2] - first pixel of the path
	566	* between moveTo/close of the
	567	* path
	568	*
	569	* pixelInfo[3,4] - last drawn pixel between
	570	* moveTo/close of the path
	571	*
	572	* checkBounds - flag showing necessity of checking the clip
	573	*
	574	*/
	575	public void processFixedLine(int x1, int y1, int x2, int y2,
	576	int[] pixelInfo, boolean checkBounds,
	577	boolean endSubPath) {
	578
	579	/* Checking if line is inside a (X,Y),(X+MDP_MULT,Y+MDP_MULT) box */
	580	int c = ((x1 ^ x2) \| (y1 ^ y2));
	581	int rx1, ry1, rx2, ry2;
	582	if ((c & MDP_W_MASK) == 0) {
	583	/* Checking for the segments with integer coordinates having
	584	* the same start and end points
	585	*/
	586	if (c == 0) {
	587	PROCESS_POINT(x1 + MDP_HALF_MULT, y1 + MDP_HALF_MULT,
	588	checkBounds, pixelInfo);
	589	}
	590	return;
	591	}
	592
	593	if (x1 == x2 \|\| y1 == y2) {
	594	rx1 = x1 + MDP_HALF_MULT;
	595	rx2 = x2 + MDP_HALF_MULT;
	596	ry1 = y1 + MDP_HALF_MULT;
	597	ry2 = y2 + MDP_HALF_MULT;
	598	} else {
	599	/* Neither dx nor dy can be zero because of the check above */
	600	int dx = x2 - x1;
	601	int dy = y2 - y1;
	602
	603	/* Floor of x1, y1, x2, y2 */
	604	int fx1 = x1 & MDP_W_MASK;
	605	int fy1 = y1 & MDP_W_MASK;
	606	int fx2 = x2 & MDP_W_MASK;
	607	int fy2 = y2 & MDP_W_MASK;
	608
	609	/* Processing first endpoint */
	610	if (fx1 == x1 \|\| fy1 == y1) {
	611	/* Adding MDP_HALF_MULT to the [xy]1 if f[xy]1 == [xy]1
	612	* will not affect the result
	613	*/
	614	rx1 = x1 + MDP_HALF_MULT;
	615	ry1 = y1 + MDP_HALF_MULT;
	616	} else {
	617	/* Boundary at the direction from (x1,y1) to (x2,y2) */
	618	int bx1 = (x1 < x2) ? fx1 + MDP_MULT : fx1;
	619	int by1 = (y1 < y2) ? fy1 + MDP_MULT : fy1;
	620
	621	/* intersection with column bx1 */
	622	int cross = y1 + ((bx1 - x1)*dy)/dx;
	623	if (cross >= fy1 && cross <= fy1 + MDP_MULT) {
	624	rx1 = bx1;
	625	ry1 = cross + MDP_HALF_MULT;
	626	} else {
	627	/* intersection with row by1 */
	628	cross = x1 + ((by1 - y1)*dx)/dy;
	629	rx1 = cross + MDP_HALF_MULT;
	630	ry1 = by1;
	631	}
	632	}
	633
	634	/* Processing second endpoint */
	635	if (fx2 == x2 \|\| fy2 == y2) {
	636	/* Adding MDP_HALF_MULT to the [xy]2 if f[xy]2 == [xy]2
	637	* will not affect the result
	638	*/
	639	rx2 = x2 + MDP_HALF_MULT;
	640	ry2 = y2 + MDP_HALF_MULT;
	641	} else {
	642	/* Boundary at the direction from (x2,y2) to (x1,y1) */
	643	int bx2 = (x1 > x2) ? fx2 + MDP_MULT : fx2;
	644	int by2 = (y1 > y2) ? fy2 + MDP_MULT : fy2;
	645
	646	/* intersection with column bx2 */
	647	int cross = y2 + ((bx2 - x2)*dy)/dx;
	648	if (cross >= fy2 && cross <= fy2 + MDP_MULT) {
	649	rx2 = bx2;
	650	ry2 = cross + MDP_HALF_MULT;
	651	} else {
	652	/* intersection with row by2 */
	653	cross = x2 + ((by2 - y2)*dx)/dy;
	654	rx2 = cross + MDP_HALF_MULT;
	655	ry2 = by2;
	656	}
	657	}
	658	}
	659	PROCESS_LINE(rx1, ry1, rx2, ry2, checkBounds, pixelInfo);
	660	}
	661	}
	662
	663	/* Performing drawing of the monotonic in X and Y quadratic curves with
	664	* sizes less than MAX_QUAD_SIZE by using forward differencing method of
	665	* calculation. See comments to the DrawMonotonicQuad in the
	666	* ProcessGeneralPath.c
	667	*/
	668	private static void DrawMonotonicQuad(ProcessHandler hnd,
	669	float[] coords,
	670	boolean checkBounds,
	671	int[] pixelInfo) {
	672
	673	int x0 = (int)(coords[0]*MDP_MULT);
	674	int y0 = (int)(coords[1]*MDP_MULT);
	675
	676	int xe = (int)(coords[4]*MDP_MULT);
	677	int ye = (int)(coords[5]*MDP_MULT);
	678
	679	/* Extracting fractional part of coordinates of first control point */
	680	int px = (x0 & (~MDP_W_MASK)) << DF_QUAD_SHIFT;
	681	int py = (y0 & (~MDP_W_MASK)) << DF_QUAD_SHIFT;
	682
	683	/* Setting default amount of steps */
	684	int count = DF_QUAD_COUNT;
	685
	686	/* Setting default shift for preparing to the midpoint rounding */
	687	int shift = DF_QUAD_SHIFT;
	688
	689	int ax = (int)((coords[0] - 2*coords[2] +
	690	coords[4])*QUAD_A_MDP_MULT);
	691	int ay = (int)((coords[1] - 2*coords[3] +
	692	coords[5])*QUAD_A_MDP_MULT);
	693
	694	int bx = (int)((-2coords[0] + 2coords[2])*QUAD_B_MDP_MULT);
	695	int by = (int)((-2coords[1] + 2coords[3])*QUAD_B_MDP_MULT);
	696
	697	int ddpx = 2*ax;
	698	int ddpy = 2*ay;
	699
	700	int dpx = ax + bx;
	701	int dpy = ay + by;
	702
	703	int x1, y1;
	704
	705	int x2 = x0;
	706	int y2 = y0;
	707
	708	int maxDD = Math.max(Math.abs(ddpx),Math.abs(ddpy));
	709
	710	int dx = xe - x0;
	711	int dy = ye - y0;
	712
	713	int x0w = x0 & MDP_W_MASK;
	714	int y0w = y0 & MDP_W_MASK;
	715
	716	/* Perform decreasing step in 2 times if slope of the first forward
	717	* difference changes too quickly (more than a pixel per step in X or Y
	718	* direction). We can perform adjusting of the step size before the
	719	* rendering loop because the curvature of the quad curve remains the
	720	* same along all the curve
	721	*/
	722	while (maxDD > DF_QUAD_DEC_BND) {
	723	dpx = (dpx<<1) - ax;
	724	dpy = (dpy<<1) - ay;
	725	count <<= 1;
	726	maxDD >>= 2;
	727	px <<=2;
	728	py <<=2;
	729	shift += 2;
	730	}
	731
	732	while(count-- > 1) {
	733	px += dpx;
	734	py += dpy;
	735
	736	dpx += ddpx;
	737	dpy += ddpy;
	738
	739	x1 = x2;
	740	y1 = y2;
	741
	742	x2 = x0w + (px >> shift);
	743	y2 = y0w + (py >> shift);
	744
	745	/* Checking that we are not running out of the endpoint and bounding
	746	* violating coordinate. The check is pretty simple because the
	747	* curve passed to the DrawCubic already splitted into the
	748	* monotonic in X and Y pieces
	749	*/
	750
	751	/* Bounding x2 by xe */
	752	if (((xe-x2)^dx) < 0) {
	753	x2 = xe;
	754	}
	755
	756	/* Bounding y2 by ye */
	757	if (((ye-y2)^dy) < 0) {
	758	y2 = ye;
	759	}
	760
	761	hnd.processFixedLine(x1, y1, x2, y2, pixelInfo, checkBounds, false);
	762	}
	763
	764	/* We are performing one step less than necessary and use actual
	765	* (xe,ye) endpoint of the curve instead of calculated. This prevent us
	766	* from running above the curve endpoint due to the accumulated errors
	767	* during the iterations.
	768	*/
	769
	770	hnd.processFixedLine(x2, y2, xe, ye, pixelInfo, checkBounds, false);
	771	}
	772
	773	/*
	774	* Checking size of the quad curves and split them if necessary.
	775	* Calling DrawMonotonicQuad for the curves of the appropriate size.
	776	* Note: coords array could be changed
	777	*/
	778	private static void ProcessMonotonicQuad(ProcessHandler hnd,
	779	float[] coords,
	780	int[] pixelInfo) {
	781
	782	float[] coords1 = new float[6];
	783	float tx, ty;
	784	float xMin, yMin, xMax, yMax;
	785
	786	xMin = xMax = coords[0];
	787	yMin = yMax = coords[1];
	788	for (int i = 2; i < 6; i += 2) {
	789	xMin = (xMin > coords[i])? coords[i] : xMin;
	790	xMax = (xMax < coords[i])? coords[i] : xMax;
	791	yMin = (yMin > coords[i + 1])? coords[i + 1] : yMin;
	792	yMax = (yMax < coords[i + 1])? coords[i + 1] : yMax;
	793	}
	794
	795	if (hnd.clipMode == PH_MODE_DRAW_CLIP) {
	796
	797	/* In case of drawing we could just skip curves which are
	798	* completely out of bounds
	799	*/
	800	if (hnd.dhnd.xMaxf < xMin \|\| hnd.dhnd.xMinf > xMax \|\|
	801	hnd.dhnd.yMaxf < yMin \|\| hnd.dhnd.yMinf > yMax) {
	802	return;
	803	}
	804	} else {
	805
	806	/* In case of filling we could skip curves which are above,
	807	* below and behind the right boundary of the visible area
	808	*/
	809
	810	if (hnd.dhnd.yMaxf < yMin \|\| hnd.dhnd.yMinf > yMax \|\|
	811	hnd.dhnd.xMaxf < xMin)
	812	{
	813	return;
	814	}
	815
	816	/* We could clamp x coordinates to the corresponding boundary
	817	* if the curve is completely behind the left one
	818	*/
	819
	820	if (hnd.dhnd.xMinf > xMax) {
	821	coords[0] = coords[2] = coords[4] = hnd.dhnd.xMinf;
	822	}
	823	}
	824
	825	if (xMax - xMin > MAX_QUAD_SIZE \|\| yMax - yMin > MAX_QUAD_SIZE) {
	826	coords1[4] = coords[4];
	827	coords1[5] = coords[5];
	828	coords1[2] = (coords[2] + coords[4])/2.0f;
	829	coords1[3] = (coords[3] + coords[5])/2.0f;
	830	coords[2] = (coords[0] + coords[2])/2.0f;
	831	coords[3] = (coords[1] + coords[3])/2.0f;
	832	coords[4] = coords1[0] = (coords[2] + coords1[2])/2.0f;
	833	coords[5] = coords1[1] = (coords[3] + coords1[3])/2.0f;
	834
	835	ProcessMonotonicQuad(hnd, coords, pixelInfo);
	836
	837	ProcessMonotonicQuad(hnd, coords1, pixelInfo);
	838	} else {
	839	DrawMonotonicQuad(hnd, coords,
	840	/* Set checkBounds parameter if curve intersects
	841	* boundary of the visible area. We know that the
	842	* curve is visible, so the check is pretty
	843	* simple
	844	*/
	845	hnd.dhnd.xMinf >= xMin \|\|
	846	hnd.dhnd.xMaxf <= xMax \|\|
	847	hnd.dhnd.yMinf >= yMin \|\|
	848	hnd.dhnd.yMaxf <= yMax,
	849	pixelInfo);
	850	}
	851	}
	852
	853	/*
	854	* Split quadratic curve into monotonic in X and Y parts. Calling
	855	* ProcessMonotonicQuad for each monotonic piece of the curve.
	856	* Note: coords array could be changed
	857	*/
	858	private static void ProcessQuad(ProcessHandler hnd, float[] coords,
	859	int[] pixelInfo) {
	860	/* Temporary array for holding parameters corresponding to the extreme
	861	* in X and Y points
	862	*/
	863	double params[] = new double[2];
	864	int cnt = 0;
	865	double param;
	866
	867	/* Simple check for monotonicity in X before searching for the extreme
	868	* points of the X(t) function. We first check if the curve is
	869	* monotonic in X by seeing if all of the X coordinates are strongly
	870	* ordered.
	871	*/
	872	if ((coords[0] > coords[2] \|\| coords[2] > coords[4]) &&
	873	(coords[0] < coords[2] \|\| coords[2] < coords[4]))
	874	{
	875	/* Searching for extreme points of the X(t) function by solving
	876	* dX(t)
	877	* ---- = 0 equation
	878	* dt
	879	*/
	880	double ax = coords[0] - 2*coords[2] + coords[4];
	881	if (ax != 0) {
	882	/* Calculating root of the following equation
	883	* ax*t + bx = 0
	884	*/
	885	double bx = coords[0] - coords[2];
	886
	887	param = bx/ax;
	888	if (param < 1.0 && param > 0.0) {
	889	params[cnt++] = param;
	890	}
	891	}
	892	}
	893
	894	/* Simple check for monotonicity in Y before searching for the extreme
	895	* points of the Y(t) function. We first check if the curve is
	896	* monotonic in Y by seeing if all of the Y coordinates are strongly
	897	* ordered.
	898	*/
	899	if ((coords[1] > coords[3] \|\| coords[3] > coords[5]) &&
	900	(coords[1] < coords[3] \|\| coords[3] < coords[5]))
	901	{
	902	/* Searching for extreme points of the Y(t) function by solving
	903	* dY(t)
	904	* ----- = 0 equation
	905	* dt
	906	*/
	907	double ay = coords[1] - 2*coords[3] + coords[5];
	908
	909	if (ay != 0) {
	910	/* Calculating root of the following equation
	911	* ay*t + by = 0
	912	*/
	913	double by = coords[1] - coords[3];
	914
	915	param = by/ay;
	916	if (param < 1.0 && param > 0.0) {
	917	if (cnt > 0) {
	918	/* Inserting parameter only if it differs from
	919	* already stored
	920	*/
	921	if (params[0] > param) {
	922	params[cnt++] = params[0];
	923	params[0] = param;
	924	} else if (params[0] < param) {
	925	params[cnt++] = param;
	926	}
	927	} else {
	928	params[cnt++] = param;
	929	}
	930	}
	931	}
	932	}
	933
	934	/* Processing obtained monotonic parts */
	935	switch(cnt) {
	936	case 0:
	937	break;
	938	case 1:
	939	ProcessFirstMonotonicPartOfQuad(hnd, coords, pixelInfo,
	940	(float)params[0]);
	941	break;
	942	case 2:
	943	ProcessFirstMonotonicPartOfQuad(hnd, coords, pixelInfo,
	944	(float)params[0]);
	945	param = params[1] - params[0];
	946	if (param > 0) {
	947	ProcessFirstMonotonicPartOfQuad(hnd, coords, pixelInfo,
	948	/* Scale parameter to match with
	949	* rest of the curve
	950	*/
	951	(float)(param/(1.0 - params[0])));
	952	}
	953	break;
	954	}
	955
	956	ProcessMonotonicQuad(hnd,coords,pixelInfo);
	957	}
	958
	959	/*
	960	* Bite the piece of the quadratic curve from start point till the point
	961	* corresponding to the specified parameter then call ProcessQuad for the
	962	* bitten part.
	963	* Note: coords array will be changed
	964	*/
	965	private static void ProcessFirstMonotonicPartOfQuad(ProcessHandler hnd,
	966	float[] coords,
	967	int[] pixelInfo,
	968	float t) {
	969	float[] coords1 = new float[6];
	970
	971	coords1[0] = coords[0];
	972	coords1[1] = coords[1];
	973	coords1[2] = coords[0] + t*(coords[2] - coords[0]);
	974	coords1[3] = coords[1] + t*(coords[3] - coords[1]);
	975	coords[2] = coords[2] + t*(coords[4] - coords[2]);
	976	coords[3] = coords[3] + t*(coords[5] - coords[3]);
	977	coords[0] = coords1[4] = coords1[2] + t*(coords[2] - coords1[2]);
	978	coords[1] = coords1[5] = coords1[3] + t*(coords[3] - coords1[3]);
	979
	980	ProcessMonotonicQuad(hnd, coords1, pixelInfo);
	981	}
	982
	983	/* Performing drawing of the monotonic in X and Y cubic curves with sizes
	984	* less than MAX_CUB_SIZE by using forward differencing method of
	985	* calculation. See comments to the DrawMonotonicCubic in the
	986	* ProcessGeneralPath.c
	987	*/
	988	private static void DrawMonotonicCubic(ProcessHandler hnd,
	989	float[] coords,
	990	boolean checkBounds,
	991	int[] pixelInfo) {
	992	int x0 = (int)(coords[0]*MDP_MULT);
	993	int y0 = (int)(coords[1]*MDP_MULT);
	994
	995	int xe = (int)(coords[6]*MDP_MULT);
	996	int ye = (int)(coords[7]*MDP_MULT);
	997
	998	/* Extracting fractional part of coordinates of first control point */
	999	int px = (x0 & (~MDP_W_MASK)) << DF_CUB_SHIFT;
	1000	int py = (y0 & (~MDP_W_MASK)) << DF_CUB_SHIFT;
	1001
	1002	/* Setting default boundary values for checking first and second forward
	1003	* difference for the necessity of the restepping. See comments to the
	1004	* boundary values in ProcessQuad for more info.
	1005	*/
	1006	int incStepBnd = DF_CUB_INC_BND;
	1007	int decStepBnd = DF_CUB_DEC_BND;
	1008
	1009	/* Setting default amount of steps */
	1010	int count = DF_CUB_COUNT;
	1011
	1012	/* Setting default shift for preparing to the midpoint rounding */
	1013	int shift = DF_CUB_SHIFT;
	1014
	1015	int ax = (int)((-coords[0] + 3coords[2] - 3coords[4] +
	1016	coords[6])*CUB_A_MDP_MULT);
	1017	int ay = (int)((-coords[1] + 3coords[3] - 3coords[5] +
	1018	coords[7])*CUB_A_MDP_MULT);
	1019
	1020	int bx = (int)((3coords[0] - 6coords[2] +
	1021	3coords[4])CUB_B_MDP_MULT);
	1022	int by = (int)((3coords[1] - 6coords[3] +
	1023	3coords[5])CUB_B_MDP_MULT);
	1024
	1025	int cx = (int)((-3coords[0] + 3coords[2])*(CUB_C_MDP_MULT));
	1026	int cy = (int)((-3coords[1] + 3coords[3])*(CUB_C_MDP_MULT));
	1027
	1028	int dddpx = 6*ax;
	1029	int dddpy = 6*ay;
	1030
	1031	int ddpx = dddpx + bx;
	1032	int ddpy = dddpy + by;
	1033
	1034	int dpx = ax + (bx>>1) + cx;
	1035	int dpy = ay + (by>>1) + cy;
	1036
	1037	int x1, y1;
	1038
	1039	int x2 = x0;
	1040	int y2 = y0;
	1041
	1042	/* Calculating whole part of the first point of the curve */
	1043	int x0w = x0 & MDP_W_MASK;
	1044	int y0w = y0 & MDP_W_MASK;
	1045
	1046	int dx = xe - x0;
	1047	int dy = ye - y0;
	1048
	1049	while (count > 0) {
	1050	/* Perform decreasing step in 2 times if necessary */
	1051	while (Math.abs(ddpx) > decStepBnd \|\|
	1052	Math.abs(ddpy) > decStepBnd) {
	1053	ddpx = (ddpx<<1) - dddpx;
	1054	ddpy = (ddpy<<1) - dddpy;
	1055	dpx = (dpx<<2) - (ddpx>>1);
	1056	dpy = (dpy<<2) - (ddpy>>1);
	1057	count <<=1;
	1058	decStepBnd <<=3;
	1059	incStepBnd <<=3;
	1060	px <<=3;
	1061	py <<=3;
	1062	shift += 3;
	1063	}
	1064
	1065	/* Perform increasing step in 2 times if necessary.
	1066	* Note: we could do it only in even steps
	1067	*/
	1068
	1069	while ((count & 1) == 0 && shift > DF_CUB_SHIFT &&
	1070	Math.abs(dpx) <= incStepBnd &&
	1071	Math.abs(dpy) <= incStepBnd) {
	1072	dpx = (dpx>>2) + (ddpx>>3);
	1073	dpy = (dpy>>2) + (ddpy>>3);
	1074	ddpx = (ddpx + dddpx)>>1;
	1075	ddpy = (ddpy + dddpy)>>1;
	1076	count >>=1;
	1077	decStepBnd >>=3;
	1078	incStepBnd >>=3;
	1079	px >>=3;
	1080	py >>=3;
	1081	shift -= 3;
	1082	}
	1083
	1084	count--;
	1085
	1086	/* Performing one step less than necessary and use actual (xe,ye)
	1087	* curve's endpoint instead of calculated. This prevent us from
	1088	* running above the curve endpoint due to the accumulated errors
	1089	* during the iterations.
	1090	*/
	1091	if (count > 0) {
	1092	px += dpx;
	1093	py += dpy;
	1094
	1095	dpx += ddpx;
	1096	dpy += ddpy;
	1097	ddpx += dddpx;
	1098	ddpy += dddpy;
	1099
	1100	x1 = x2;
	1101	y1 = y2;
	1102
	1103	x2 = x0w + (px >> shift);
	1104	y2 = y0w + (py >> shift);
	1105
	1106	/* Checking that we are not running out of the endpoint and
	1107	* bounding violating coordinate. The check is pretty simple
	1108	* because the curve passed to the DrawCubic already splitted
	1109	* into the monotonic in X and Y pieces
	1110	*/
	1111
	1112	/* Bounding x2 by xe */
	1113	if (((xe-x2)^dx) < 0) {
	1114	x2 = xe;
	1115	}
	1116
	1117	/* Bounding y2 by ye */
	1118	if (((ye-y2)^dy) < 0) {
	1119	y2 = ye;
	1120	}
	1121
	1122	hnd.processFixedLine(x1, y1, x2, y2, pixelInfo, checkBounds,
	1123	false);
	1124	} else {
	1125	hnd.processFixedLine(x2, y2, xe, ye, pixelInfo, checkBounds,
	1126	false);
	1127	}
	1128	}
	1129	}
	1130
	1131	/*
	1132	* Checking size of the cubic curves and split them if necessary.
	1133	* Calling DrawMonotonicCubic for the curves of the appropriate size.
	1134	* Note: coords array could be changed
	1135	*/
	1136	private static void ProcessMonotonicCubic(ProcessHandler hnd,
	1137	float[] coords,
	1138	int[] pixelInfo) {
	1139
	1140	float[] coords1 = new float[8];
	1141	float tx, ty;
	1142	float xMin, xMax;
	1143	float yMin, yMax;
	1144
	1145	xMin = xMax = coords[0];
	1146	yMin = yMax = coords[1];
	1147
	1148	for (int i = 2; i < 8; i += 2) {
	1149	xMin = (xMin > coords[i])? coords[i] : xMin;
	1150	xMax = (xMax < coords[i])? coords[i] : xMax;
	1151	yMin = (yMin > coords[i + 1])? coords[i + 1] : yMin;
	1152	yMax = (yMax < coords[i + 1])? coords[i + 1] : yMax;
	1153	}
	1154
	1155	if (hnd.clipMode == PH_MODE_DRAW_CLIP) {
	1156	/* In case of drawing we could just skip curves which are
	1157	* completely out of bounds
	1158	*/
	1159	if (hnd.dhnd.xMaxf < xMin \|\| hnd.dhnd.xMinf > xMax \|\|
	1160	hnd.dhnd.yMaxf < yMin \|\| hnd.dhnd.yMinf > yMax) {
	1161	return;
	1162	}
	1163	} else {
	1164
	1165	/* In case of filling we could skip curves which are above,
	1166	* below and behind the right boundary of the visible area
	1167	*/
	1168
	1169	if (hnd.dhnd.yMaxf < yMin \|\| hnd.dhnd.yMinf > yMax \|\|
	1170	hnd.dhnd.xMaxf < xMin)
	1171	{
	1172	return;
	1173	}
	1174
	1175	/* We could clamp x coordinates to the corresponding boundary
	1176	* if the curve is completely behind the left one
	1177	*/
	1178
	1179	if (hnd.dhnd.xMinf > xMax) {
	1180	coords[0] = coords[2] = coords[4] = coords[6] =
	1181	hnd.dhnd.xMinf;
	1182	}
	1183	}
	1184
	1185	if (xMax - xMin > MAX_CUB_SIZE \|\| yMax - yMin > MAX_CUB_SIZE) {
	1186	coords1[6] = coords[6];
	1187	coords1[7] = coords[7];
	1188	coords1[4] = (coords[4] + coords[6])/2.0f;
	1189	coords1[5] = (coords[5] + coords[7])/2.0f;
	1190	tx = (coords[2] + coords[4])/2.0f;
	1191	ty = (coords[3] + coords[5])/2.0f;
	1192	coords1[2] = (tx + coords1[4])/2.0f;
	1193	coords1[3] = (ty + coords1[5])/2.0f;
	1194	coords[2] = (coords[0] + coords[2])/2.0f;
	1195	coords[3] = (coords[1] + coords[3])/2.0f;
	1196	coords[4] = (coords[2] + tx)/2.0f;
	1197	coords[5] = (coords[3] + ty)/2.0f;
	1198	coords[6]=coords1[0]=(coords[4] + coords1[2])/2.0f;
	1199	coords[7]=coords1[1]=(coords[5] + coords1[3])/2.0f;
	1200
	1201	ProcessMonotonicCubic(hnd, coords, pixelInfo);
	1202
	1203	ProcessMonotonicCubic(hnd, coords1, pixelInfo);
	1204	} else {
	1205	DrawMonotonicCubic(hnd, coords,
	1206	/* Set checkBounds parameter if curve intersects
	1207	* boundary of the visible area. We know that
	1208	* the curve is visible, so the check is pretty
	1209	* simple
	1210	*/
	1211	hnd.dhnd.xMinf > xMin \|\|
	1212	hnd.dhnd.xMaxf < xMax \|\|
	1213	hnd.dhnd.yMinf > yMin \|\|
	1214	hnd.dhnd.yMaxf < yMax,
	1215	pixelInfo);
	1216	}
	1217	}
	1218
	1219	/*
	1220	* Split cubic curve into monotonic in X and Y parts. Calling
	1221	* ProcessMonotonicCubic for each monotonic piece of the curve.
	1222	*
	1223	* Note: coords array could be changed
	1224	*/
	1225	private static void ProcessCubic(ProcessHandler hnd,
	1226	float[] coords,
	1227	int[] pixelInfo) {
	1228	/* Temporary array for holding parameters corresponding to the extreme
	1229	* in X and Y points
	1230	*/
	1231	double params[] = new double[4];
	1232	double eqn[] = new double[3];
	1233	double res[] = new double[2];
	1234	int cnt = 0;
	1235
	1236	/* Simple check for monotonicity in X before searching for the extreme
	1237	* points of the X(t) function. We first check if the curve is
	1238	* monotonic in X by seeing if all of the X coordinates are strongly
	1239	* ordered.
	1240	*/
	1241	if ((coords[0] > coords[2] \|\| coords[2] > coords[4] \|\|
	1242	coords[4] > coords[6]) &&
	1243	(coords[0] < coords[2] \|\| coords[2] < coords[4] \|\|
	1244	coords[4] < coords[6]))
	1245	{
	1246	/* Searching for extreme points of the X(t) function by solving
	1247	* dX(t)
	1248	* ---- = 0 equation
	1249	* dt
	1250	*/
	1251	eqn[2] = -coords[0] + 3coords[2] - 3coords[4] + coords[6];
	1252	eqn[1] = 2(coords[0] - 2coords[2] + coords[4]);
	1253	eqn[0] = -coords[0] + coords[2];
	1254
	1255	int nr = QuadCurve2D.solveQuadratic(eqn, res);
	1256
	1257	/* Following code also correctly works in degenerate case of
	1258	* the quadratic equation (nr = -1) because we do not need
	1259	* splitting in this case.
	1260	*/
	1261	for (int i = 0; i < nr; i++) {
	1262	if (res[i] > 0 && res[i] < 1) {
	1263	params[cnt++] = res[i];
	1264	}
	1265	}
	1266	}
	1267
	1268	/* Simple check for monotonicity in Y before searching for the extreme
	1269	* points of the Y(t) function. We first check if the curve is
	1270	* monotonic in Y by seeing if all of the Y coordinates are strongly
	1271	* ordered.
	1272	*/
	1273	if ((coords[1] > coords[3] \|\| coords[3] > coords[5] \|\|
	1274	coords[5] > coords[7]) &&
	1275	(coords[1] < coords[3] \|\| coords[3] < coords[5] \|\|
	1276	coords[5] < coords[7]))
	1277	{
	1278	/* Searching for extreme points of the Y(t) function by solving
	1279	* dY(t)
	1280	* ----- = 0 equation
	1281	* dt
	1282	*/
	1283	eqn[2] = -coords[1] + 3coords[3] - 3coords[5] + coords[7];
	1284	eqn[1] = 2(coords[1] - 2coords[3] + coords[5]);
	1285	eqn[0] = -coords[1] + coords[3];
	1286
	1287	int nr = QuadCurve2D.solveQuadratic(eqn, res);
	1288
	1289	/* Following code also correctly works in degenerate case of
	1290	* the quadratic equation (nr = -1) because we do not need
	1291	* splitting in this case.
	1292	*/
	1293	for (int i = 0; i < nr; i++) {
	1294	if (res[i] > 0 && res[i] < 1) {
	1295	params[cnt++] = res[i];
	1296	}
	1297	}
	1298	}
	1299
	1300	if (cnt > 0) {
	1301	/* Sorting parameter values corresponding to the extreme points
	1302	* of the curve
	1303	*/
	1304	Arrays.sort(params, 0, cnt);
	1305
	1306	/* Processing obtained monotonic parts */
	1307	ProcessFirstMonotonicPartOfCubic(hnd, coords, pixelInfo,
	1308	(float)params[0]);
	1309	for (int i = 1; i < cnt; i++) {
	1310	double param = params[i] - params[i-1];
	1311	if (param > 0) {
	1312	ProcessFirstMonotonicPartOfCubic(hnd, coords, pixelInfo,
	1313	/* Scale parameter to match with rest of the curve */
	1314	(float)(param/(1.0 - params[i - 1])));
	1315	}
	1316	}
	1317	}
	1318
	1319	ProcessMonotonicCubic(hnd,coords,pixelInfo);
	1320	}
	1321
	1322	/*
	1323	* Bite the piece of the cubic curve from start point till the point
	1324	* corresponding to the specified parameter then call ProcessCubic for the
	1325	* bitten part.
	1326	* Note: coords array will be changed
	1327	*/
	1328	private static void ProcessFirstMonotonicPartOfCubic(ProcessHandler hnd,
	1329	float[] coords,
	1330	int[] pixelInfo,
	1331	float t)
	1332	{
	1333	float[] coords1 = new float[8];
	1334	float tx, ty;
	1335
	1336	coords1[0] = coords[0];
	1337	coords1[1] = coords[1];
	1338	tx = coords[2] + t*(coords[4] - coords[2]);
	1339	ty = coords[3] + t*(coords[5] - coords[3]);
	1340	coords1[2] = coords[0] + t*(coords[2] - coords[0]);
	1341	coords1[3] = coords[1] + t*(coords[3] - coords[1]);
	1342	coords1[4] = coords1[2] + t*(tx - coords1[2]);
	1343	coords1[5] = coords1[3] + t*(ty - coords1[3]);
	1344	coords[4] = coords[4] + t*(coords[6] - coords[4]);
	1345	coords[5] = coords[5] + t*(coords[7] - coords[5]);
	1346	coords[2] = tx + t*(coords[4] - tx);
	1347	coords[3] = ty + t*(coords[5] - ty);
	1348	coords[0]=coords1[6]=coords1[4] + t*(coords[2] - coords1[4]);
	1349	coords[1]=coords1[7]=coords1[5] + t*(coords[3] - coords1[5]);
	1350
	1351	ProcessMonotonicCubic(hnd, coords1, pixelInfo);
	1352	}
	1353
	1354	/* Note:
	1355	* For more easy reading of the code below each java version of the macros
	1356	* from the ProcessPath.c preceded by the commented origin call
	1357	* containing verbose names of the parameters
	1358	*/
	1359	private static void ProcessLine(ProcessHandler hnd, float x1, float y1,
	1360	float x2, float y2, int[] pixelInfo) {
	1361	float xMin, yMin, xMax, yMax;
	1362	int X1, Y1, X2, Y2, X3, Y3, res;
	1363	boolean clipped = false;
	1364	float x3,y3;
	1365	float c[] = new float[]{x1, y1, x2, y2, 0, 0};
	1366
	1367	boolean lastClipped;
	1368
	1369	xMin = hnd.dhnd.xMinf;
	1370	yMin = hnd.dhnd.yMinf;
	1371	xMax = hnd.dhnd.xMaxf;
	1372	yMax = hnd.dhnd.yMaxf;
	1373
	1374	//
	1375	// TESTANDCLIP(yMin, yMax, y1, x1, y2, x2, res);
	1376	//
	1377	res = TESTANDCLIP(yMin, yMax, c, 1, 0, 3, 2);
	1378	if (res == CRES_INVISIBLE) return;
	1379	clipped = IS_CLIPPED(res);
	1380	//
	1381	// TESTANDCLIP(yMin, yMax, y2, x2, y1, x1, res);
	1382	//
	1383	res = TESTANDCLIP(yMin, yMax, c, 3, 2, 1, 0);
	1384	if (res == CRES_INVISIBLE) return;
	1385	lastClipped = IS_CLIPPED(res);
	1386	clipped = clipped \|\| lastClipped;
	1387
	1388	if (hnd.clipMode == PH_MODE_DRAW_CLIP) {
	1389	//
	1390	// TESTANDCLIP(xMin, xMax, x1, y1, x2, y2, res);
	1391	//
	1392	res = TESTANDCLIP(xMin, xMax, c, 0, 1, 2, 3);
	1393	if (res == CRES_INVISIBLE) return;
	1394	clipped = clipped \|\| IS_CLIPPED(res);
	1395	//
	1396	// TESTANDCLIP(xMin, xMax, x2, y2, x1, y1, res);
	1397	//
	1398	res = TESTANDCLIP(xMin, xMax, c, 2, 3, 0, 1);
	1399	if (res == CRES_INVISIBLE) return;
	1400	lastClipped = lastClipped \|\| IS_CLIPPED(res);
	1401	clipped = clipped \|\| lastClipped;
	1402	X1 = (int)(c[0]*MDP_MULT);
	1403	Y1 = (int)(c[1]*MDP_MULT);
	1404	X2 = (int)(c[2]*MDP_MULT);
	1405	Y2 = (int)(c[3]*MDP_MULT);
	1406
	1407	hnd.processFixedLine(X1, Y1, X2, Y2, pixelInfo,
	1408	clipped, /* enable boundary checking in
	1409	case of clipping to avoid
	1410	entering out of bounds which
	1411	could happens during rounding
	1412	*/
	1413	lastClipped /* Notify pProcessFixedLine
	1414	that
	1415	this is the end of the
	1416	subpath (because of exiting
	1417	out of boundaries)
	1418	*/
	1419	);
	1420	} else {
	1421	/* Clamping starting from first vertex of the the processed
	1422	* segment
	1423	*
	1424	* CLIPCLAMP(xMin, xMax, x1, y1, x2, y2, x3, y3, res);
	1425	*/
	1426	res = CLIPCLAMP(xMin, xMax, c, 0, 1, 2, 3, 4, 5);
	1427	X1 = (int)(c[0]*MDP_MULT);
	1428	Y1 = (int)(c[1]*MDP_MULT);
	1429
	1430	/* Clamping only by left boundary */
	1431	if (res == CRES_MIN_CLIPPED) {
	1432	X3 = (int)(c[4]*MDP_MULT);
	1433	Y3 = (int)(c[5]*MDP_MULT);
	1434	hnd.processFixedLine(X3, Y3, X1, Y1, pixelInfo,
	1435	false, lastClipped);
	1436
	1437	} else if (res == CRES_INVISIBLE) {
	1438	return;
	1439	}
	1440
	1441	/* Clamping starting from last vertex of the the processed
	1442	* segment
	1443	*
	1444	* CLIPCLAMP(xMin, xMax, x2, y2, x1, y1, x3, y3, res);
	1445	*/
	1446	res = CLIPCLAMP(xMin, xMax, c, 2, 3, 0, 1, 4, 5);
	1447
	1448	/* Checking if there was a clip by right boundary */
	1449	lastClipped = lastClipped \|\| (res == CRES_MAX_CLIPPED);
	1450
	1451	X2 = (int)(c[2]*MDP_MULT);
	1452	Y2 = (int)(c[3]*MDP_MULT);
	1453	hnd.processFixedLine(X1, Y1, X2, Y2, pixelInfo,
	1454	false, lastClipped);
	1455
	1456	/* Clamping only by left boundary */
	1457	if (res == CRES_MIN_CLIPPED) {
	1458	X3 = (int)(c[4]*MDP_MULT);
	1459	Y3 = (int)(c[5]*MDP_MULT);
	1460	hnd.processFixedLine(X2, Y2, X3, Y3, pixelInfo,
	1461	false, lastClipped);
	1462	}
	1463	}
	1464	}
	1465
	1466	private static boolean doProcessPath(ProcessHandler hnd,
	1467	Path2D.Float p2df,
	1468	float transXf, float transYf) {
	1469	float coords[] = new float[8];
	1470	float tCoords[] = new float[8];
	1471	float closeCoord[] = new float[] {0.0f, 0.0f};
	1472	float firstCoord[] = new float[2];
	1473	int pixelInfo[] = new int[5];
	1474	boolean subpathStarted = false;
	1475	boolean skip = false;
	1476	float lastX, lastY;
	1477	pixelInfo[0] = 0;
	1478
	1479	/* Adjusting boundaries to the capabilities of the
	1480	* ProcessPath code
	1481	*/
	1482	hnd.dhnd.adjustBounds(LOWER_OUT_BND, LOWER_OUT_BND,
	1483	UPPER_OUT_BND, UPPER_OUT_BND);
	1484
	1485	/* Adding support of the KEY_STROKE_CONTROL rendering hint.
	1486	* Now we are supporting two modes: "pixels at centers" and
	1487	* "pixels at corners".
	1488	* First one is disabled by default but could be enabled by setting
	1489	* VALUE_STROKE_PURE to the rendering hint. It means that pixel at the
	1490	* screen (x,y) has (x + 0.5, y + 0.5) float coordinates.
	1491	*
	1492	* Second one is enabled by default and means straightforward mapping
	1493	* (x,y) --> (x,y)
	1494	*/
	1495	if (hnd.dhnd.strokeControl == SunHints.INTVAL_STROKE_PURE) {
	1496	closeCoord[0] = -0.5f;
	1497	closeCoord[1] = -0.5f;
	1498	transXf -= 0.5;
	1499	transYf -= 0.5;
	1500	}
	1501
	1502	PathIterator pi = p2df.getPathIterator(null);
	1503
	1504	while (!pi.isDone()) {
	1505	switch (pi.currentSegment(coords)) {
	1506	case PathIterator.SEG_MOVETO:
	1507	/* Performing closing of the unclosed segments */
	1508	if (subpathStarted && !skip) {
	1509	if (hnd.clipMode == PH_MODE_FILL_CLIP) {
	1510	if (tCoords[0] != closeCoord[0] \|\|
	1511	tCoords[1] != closeCoord[1])
	1512	{
	1513	ProcessLine(hnd, tCoords[0], tCoords[1],
	1514	closeCoord[0], closeCoord[1],
	1515	pixelInfo);
	1516	}
	1517	}
	1518	hnd.processEndSubPath();
	1519	}
	1520
	1521	tCoords[0] = coords[0] + transXf;
	1522	tCoords[1] = coords[1] + transYf;
	1523
	1524	/* Checking SEG_MOVETO coordinates if they are out of the
	1525	* [LOWER_BND, UPPER_BND] range. This check also handles
	1526	* NaN and Infinity values. Skipping next path segment in
	1527	* case of invalid data.
	1528	*/
	1529
	1530	if (tCoords[0] < UPPER_BND &&
	1531	tCoords[0] > LOWER_BND &&
	1532	tCoords[1] < UPPER_BND &&
	1533	tCoords[1] > LOWER_BND)
	1534	{
	1535	subpathStarted = true;
	1536	skip = false;
	1537	closeCoord[0] = tCoords[0];
	1538	closeCoord[1] = tCoords[1];
	1539	} else {
	1540	skip = true;
	1541	}
	1542	pixelInfo[0] = 0;
	1543	break;
	1544	case PathIterator.SEG_LINETO:
	1545	lastX = tCoords[2] = coords[0] + transXf;
	1546	lastY = tCoords[3] = coords[1] + transYf;
	1547
	1548	/* Checking SEG_LINETO coordinates if they are out of the
	1549	* [LOWER_BND, UPPER_BND] range. This check also handles
	1550	* NaN and Infinity values. Ignoring current path segment
	1551	* in case of invalid data. If segment is skipped its
	1552	* endpoint (if valid) is used to begin new subpath.
	1553	*/
	1554
	1555	if (lastX < UPPER_BND &&
	1556	lastX > LOWER_BND &&
	1557	lastY < UPPER_BND &&
	1558	lastY > LOWER_BND)
	1559	{
	1560	if (skip) {
	1561	tCoords[0] = closeCoord[0] = lastX;
	1562	tCoords[1] = closeCoord[1] = lastY;
	1563	subpathStarted = true;
	1564	skip = false;
	1565	} else {
	1566	ProcessLine(hnd, tCoords[0], tCoords[1],
	1567	tCoords[2], tCoords[3], pixelInfo);
	1568	tCoords[0] = lastX;
	1569	tCoords[1] = lastY;
	1570	}
	1571	}
	1572	break;
	1573	case PathIterator.SEG_QUADTO:
	1574	tCoords[2] = coords[0] + transXf;
	1575	tCoords[3] = coords[1] + transYf;
	1576	lastX = tCoords[4] = coords[2] + transXf;
	1577	lastY = tCoords[5] = coords[3] + transYf;
	1578
	1579	/* Checking SEG_QUADTO coordinates if they are out of the
	1580	* [LOWER_BND, UPPER_BND] range. This check also handles
	1581	* NaN and Infinity values. Ignoring current path segment
	1582	* in case of invalid endpoints's data. Equivalent to
	1583	* the SEG_LINETO if endpoint coordinates are valid but
	1584	* there are invalid data among other coordinates
	1585	*/
	1586
	1587	if (lastX < UPPER_BND &&
	1588	lastX > LOWER_BND &&
	1589	lastY < UPPER_BND &&
	1590	lastY > LOWER_BND)
	1591	{
	1592	if (skip) {
	1593	tCoords[0] = closeCoord[0] = lastX;
	1594	tCoords[1] = closeCoord[1] = lastY;
	1595	subpathStarted = true;
	1596	skip = false;
	1597	} else {
	1598	if (tCoords[2] < UPPER_BND &&
	1599	tCoords[2] > LOWER_BND &&
	1600	tCoords[3] < UPPER_BND &&
	1601	tCoords[3] > LOWER_BND)
	1602	{
	1603	ProcessQuad(hnd, tCoords, pixelInfo);
	1604	} else {
	1605	ProcessLine(hnd, tCoords[0], tCoords[1],
	1606	tCoords[4], tCoords[5],
	1607	pixelInfo);
	1608	}
	1609	tCoords[0] = lastX;
	1610	tCoords[1] = lastY;
	1611	}
	1612	}
	1613	break;
	1614	case PathIterator.SEG_CUBICTO:
	1615	tCoords[2] = coords[0] + transXf;
	1616	tCoords[3] = coords[1] + transYf;
	1617	tCoords[4] = coords[2] + transXf;
	1618	tCoords[5] = coords[3] + transYf;
	1619	lastX = tCoords[6] = coords[4] + transXf;
	1620	lastY = tCoords[7] = coords[5] + transYf;
	1621
	1622	/* Checking SEG_CUBICTO coordinates if they are out of the
	1623	* [LOWER_BND, UPPER_BND] range. This check also handles
	1624	* NaN and Infinity values. Ignoring current path segment
	1625	* in case of invalid endpoints's data. Equivalent to
	1626	* the SEG_LINETO if endpoint coordinates are valid but
	1627	* there are invalid data among other coordinates
	1628	*/
	1629
	1630	if (lastX < UPPER_BND &&
	1631	lastX > LOWER_BND &&
	1632	lastY < UPPER_BND &&
	1633	lastY > LOWER_BND)
	1634	{
	1635	if (skip) {
	1636	tCoords[0] = closeCoord[0] = tCoords[6];
	1637	tCoords[1] = closeCoord[1] = tCoords[7];
	1638	subpathStarted = true;
	1639	skip = false;
	1640	} else {
	1641	if (tCoords[2] < UPPER_BND &&
	1642	tCoords[2] > LOWER_BND &&
	1643	tCoords[3] < UPPER_BND &&
	1644	tCoords[3] > LOWER_BND &&
	1645	tCoords[4] < UPPER_BND &&
	1646	tCoords[4] > LOWER_BND &&
	1647	tCoords[5] < UPPER_BND &&
	1648	tCoords[5] > LOWER_BND)
	1649	{
	1650	ProcessCubic(hnd, tCoords, pixelInfo);
	1651	} else {
	1652	ProcessLine(hnd, tCoords[0], tCoords[1],
	1653	tCoords[6], tCoords[7],
	1654	pixelInfo);
	1655	}
	1656	tCoords[0] = lastX;
	1657	tCoords[1] = lastY;
	1658	}
	1659	}
	1660	break;
	1661	case PathIterator.SEG_CLOSE:
	1662	if (subpathStarted && !skip) {
	1663	skip = false;
	1664	if (tCoords[0] != closeCoord[0] \|\|
	1665	tCoords[1] != closeCoord[1])
	1666	{
	1667	ProcessLine(hnd, tCoords[0], tCoords[1],
	1668	closeCoord[0], closeCoord[1],
	1669	pixelInfo);
	1670
	1671	/* Storing last path's point for using in following
	1672	* segments without initial moveTo
	1673	*/
	1674	tCoords[0] = closeCoord[0];
	1675	tCoords[1] = closeCoord[1];
	1676	}
	1677	hnd.processEndSubPath();
	1678	}
	1679	break;
	1680	}
	1681	pi.next();
	1682	}
	1683
	1684	/* Performing closing of the unclosed segments */
	1685	if (subpathStarted & !skip) {
	1686	if (hnd.clipMode == PH_MODE_FILL_CLIP) {
	1687	if (tCoords[0] != closeCoord[0] \|\|
	1688	tCoords[1] != closeCoord[1])
	1689	{
	1690	ProcessLine(hnd, tCoords[0], tCoords[1],
	1691	closeCoord[0], closeCoord[1],
	1692	pixelInfo);
	1693	}
	1694	}
	1695	hnd.processEndSubPath();
	1696	}
	1697	return true;
	1698	}
	1699
	1700	private static class Point {
	1701	public int x;
	1702	public int y;
	1703	public boolean lastPoint;
	1704	public Point prev;
	1705	public Point next;
	1706	public Point nextByY;
	1707	public Edge edge;
	1708	public Point(int x, int y, boolean lastPoint) {
	1709	this.x = x;
	1710	this.y = y;
	1711	this.lastPoint = lastPoint;
	1712	}
	1713	};
	1714
	1715	private static class Edge {
	1716	int x;
	1717	int dx;
	1718	Point p;
	1719	int dir;
	1720	Edge prev;
	1721	Edge next;
	1722
	1723	public Edge(Point p, int x, int dx, int dir) {
	1724	this.p = p;
	1725	this.x = x;
	1726	this.dx = dx;
	1727	this.dir = dir;
	1728	}
	1729	};
	1730
	1731	/* Size of the default buffer in the FillData structure. This buffer is
	1732	* replaced with heap allocated in case of large paths.
	1733	*/
	1734	private static final int DF_MAX_POINT = 256;
	1735
	1736	/* Following class accumulates points of the non-continuous flattened
	1737	* general path during iteration through the origin path's segments . The
	1738	* end of the each subpath is marked as lastPoint flag set at the last
	1739	* point
	1740	*/
	1741	private static class FillData {
	1742	List<Point> plgPnts;
	1743	public int plgYMin;
	1744	public int plgYMax;
	1745
	1746	public FillData() {
	1747	plgPnts = new Vector<Point>(DF_MAX_POINT);
	1748	}
	1749
	1750	public void addPoint(int x, int y, boolean lastPoint) {
	1751	if (plgPnts.size() == 0) {
	1752	plgYMin = plgYMax = y;
	1753	} else {
	1754	plgYMin = (plgYMin > y)?y:plgYMin;
	1755	plgYMax = (plgYMax < y)?y:plgYMax;
	1756	}
	1757
	1758	plgPnts.add(new Point(x, y, lastPoint));
	1759	}
	1760
	1761	public boolean isEmpty() {
	1762	return plgPnts.size() == 0;
	1763	}
	1764
	1765	public boolean isEnded() {
	1766	return plgPnts.get(plgPnts.size() - 1).lastPoint;
	1767	}
	1768
	1769	public boolean setEnded() {
	1770	return plgPnts.get(plgPnts.size() - 1).lastPoint = true;
	1771	}
	1772	}
	1773
	1774	private static class ActiveEdgeList {
	1775	Edge head;
	1776
	1777	public boolean isEmpty() {
	1778	return (head == null);
	1779	}
	1780
	1781	public void insert(Point pnt, int cy) {
	1782	Point np = pnt.next;
	1783	int X1 = pnt.x, Y1 = pnt.y;
	1784	int X2 = np.x, Y2 = np.y;
	1785	Edge ne;
	1786	if (Y1 == Y2) {
	1787	/* Skipping horizontal segments */
	1788	return;
	1789	} else {
	1790	int dX = X2 - X1;
	1791	int dY = Y2 - Y1;
	1792	int stepx, x0, dy, dir;
	1793
	1794	if (Y1 < Y2) {
	1795	x0 = X1;
	1796	dy = cy - Y1;
	1797	dir = -1;
	1798	} else { // (Y1 > Y2)
	1799	x0 = X2;
	1800	dy = cy - Y2;
	1801	dir = 1;
	1802	}
	1803
	1804	/* We need to worry only about dX because dY is in denominator
	1805	* and abs(dy) < MDP_MULT (cy is a first scanline of the scan
	1806	* converted segment and we subtract y coordinate of the
	1807	* nearest segment's end from it to obtain dy)
	1808	*/
	1809	if (dX > CALC_UBND \|\| dX < CALC_LBND) {
	1810	stepx = (int)((((double)dX)*MDP_MULT)/dY);
	1811	x0 = x0 + (int)((((double)dX)*dy)/dY);
	1812	} else {
	1813	stepx = (dX<<MDP_PREC)/dY;
	1814	x0 += (dX*dy)/dY;
	1815	}
	1816
	1817	ne = new Edge(pnt, x0, stepx, dir);
	1818	}
	1819
	1820	ne.next = head;
	1821	ne.prev = null;
	1822	if (head != null) {
	1823	head.prev = ne;
	1824	}
	1825	head = pnt.edge = ne;
	1826	}
	1827
	1828	public void delete(Edge e) {
	1829	Edge prevp = e.prev;
	1830	Edge nextp = e.next;
	1831	if (prevp != null) {
	1832	prevp.next = nextp;
	1833	} else {
	1834	head = nextp;
	1835	}
	1836	if (nextp != null) {
	1837	nextp.prev = prevp;
	1838	}
	1839	}
	1840
	1841	/**
	1842	* Bubble sorting in the ascending order of the linked list. This
	1843	* implementation stops processing the list if there were no changes
	1844	* during the previous pass.
	1845	*
	1846	* We could not use O(N) Radix sort here because in most cases list of
	1847	* edges almost sorted. So, bubble sort (O(N^2)) is working much
	1848	* better. Note, in case of array of edges Shell sort is more
	1849	* efficient.
	1850	*/
	1851	public void sort() {
	1852	Edge p, q, r, s = null, temp;
	1853	boolean wasSwap = true;
	1854
	1855	// r precedes p and s points to the node up to which
	1856	// comparisons are to be made
	1857	while (s != head.next && wasSwap) {
	1858	r = p = head;
	1859	q = p.next;
	1860	wasSwap = false;
	1861	while (p != s) {
	1862	if (p.x >= q.x) {
	1863	wasSwap = true;
	1864	if (p == head) {
	1865	temp = q.next;
	1866	q.next = p;
	1867	p.next = temp;
	1868	head = q;
	1869	r = q;
	1870	} else {
	1871	temp = q.next;
	1872	q.next = p;
	1873	p.next = temp;
	1874	r.next = q;
	1875	r = q;
	1876	}
	1877	} else {
	1878	r = p;
	1879	p = p.next;
	1880	}
	1881	q = p.next;
	1882	if (q == s) s = p;
	1883	}
	1884	}
	1885
	1886	// correction of the back links in the double linked edge list
	1887	p = head;
	1888	q = null;
	1889	while (p != null) {
	1890	p.prev = q;
	1891	q = p;
	1892	p = p.next;
	1893	}
	1894	}
	1895	}
	1896
	1897	private static void FillPolygon(FillProcessHandler hnd,
	1898	int fillRule) {
	1899	int k, y, n;
	1900	boolean drawing;
	1901	Edge active;
	1902	int rightBnd = hnd.dhnd.xMax - 1;
	1903	FillData fd = hnd.fd;
	1904	int yMin = fd.plgYMin;
	1905	int yMax = fd.plgYMax;
	1906	int hashSize = ((yMax - yMin)>>MDP_PREC) + 4;
	1907
	1908	/* Because of support of the KEY_STROKE_CONTROL hint we are performing
	1909	* shift of the coordinates at the higher level
	1910	*/
	1911	int hashOffset = ((yMin - 1) & MDP_W_MASK);
	1912
	1913	/* Winding counter */
	1914	int counter;
	1915
	1916	/* Calculating mask to be applied to the winding counter */
	1917	int counterMask =
	1918	(fillRule == PathIterator.WIND_NON_ZERO)? -1:1;
	1919
	1920	int pntOffset;
	1921	List<Point> pnts = fd.plgPnts;
	1922	n = pnts.size();
	1923
	1924	if (n <=1) return;
	1925
	1926	Point[] yHash = new Point[hashSize];
	1927
	1928	/* Creating double linked list (prev, next links) describing path order
	1929	* and hash table with points which fall between scanlines. nextByY
	1930	* link is used for the points which are between same scanlines.
	1931	* Scanlines are passed through the centers of the pixels.
	1932	*/
	1933	Point curpt = pnts.get(0);
	1934	curpt.prev = null;
	1935	for (int i = 0; i < n - 1; i++) {
	1936	curpt = pnts.get(i);
	1937	Point nextpt = pnts.get(i + 1);
	1938	int curHashInd = (curpt.y - hashOffset - 1) >> MDP_PREC;
	1939	curpt.nextByY = yHash[curHashInd];
	1940	yHash[curHashInd] = curpt;
	1941	curpt.next = nextpt;
	1942	nextpt.prev = curpt;
	1943	}
	1944
	1945	Point ept = pnts.get(n - 1);
	1946	int curHashInd = (ept.y - hashOffset - 1) >> MDP_PREC;
	1947	ept.nextByY = yHash[curHashInd];
	1948	yHash[curHashInd] = ept;
	1949
	1950	ActiveEdgeList activeList = new ActiveEdgeList();
	1951
	1952	for (y=hashOffset + MDP_MULT,k = 0;
	1953	y<=yMax && k < hashSize; y += MDP_MULT, k++)
	1954	{
	1955	for(Point pt = yHash[k];pt != null; pt=pt.nextByY) {
	1956	/* pt.y should be inside hashed interval
	1957	* assert(y-MDP_MULT <= pt.y && pt.y < y);
	1958	*/
	1959	if (pt.prev != null && !pt.prev.lastPoint) {
	1960	if (pt.prev.edge != null && pt.prev.y <= y) {
	1961	activeList.delete(pt.prev.edge);
	1962	pt.prev.edge = null;
	1963	} else if (pt.prev.y > y) {
	1964	activeList.insert(pt.prev, y);
	1965	}
	1966	}
	1967
	1968	if (!pt.lastPoint && pt.next != null) {
	1969	if (pt.edge != null && pt.next.y <= y) {
	1970	activeList.delete(pt.edge);
	1971	pt.edge = null;
	1972	} else if (pt.next.y > y) {
	1973	activeList.insert(pt, y);
	1974	}
	1975	}
	1976	}
	1977
	1978	if (activeList.isEmpty()) continue;
	1979
	1980	activeList.sort();
	1981
	1982	counter = 0;
	1983	drawing = false;
	1984	int xl, xr;
	1985	xl = xr = hnd.dhnd.xMin;
	1986	Edge curEdge = activeList.head;
	1987	while (curEdge != null) {
	1988	counter += curEdge.dir;
	1989	if ((counter & counterMask) != 0 && !drawing) {
	1990	xl = (curEdge.x + MDP_MULT - 1)>>MDP_PREC;
	1991	drawing = true;
	1992	}
	1993
	1994	if ((counter & counterMask) == 0 && drawing) {
	1995	xr = (curEdge.x - 1) >> MDP_PREC;
	1996	if (xl <= xr) {
	1997	hnd.dhnd.drawScanline(xl, xr, y >> MDP_PREC);
	1998	}
	1999	drawing = false;
	2000	}
	2001
	2002	curEdge.x += curEdge.dx;
	2003	curEdge = curEdge.next;
	2004	}
	2005
	2006	/* Performing drawing till the right boundary (for correct
	2007	* rendering shapes clipped at the right side)
	2008	*/
	2009	if (drawing && xl <= rightBnd) {
	2010
	2011	/* Support of the strokeHint was added into the
	2012	* draw and fill methods of the sun.java2d.pipe.LoopPipe
	2013	*/
	2014	hnd.dhnd.drawScanline(xl, rightBnd, y >> MDP_PREC);
	2015	}
	2016	}
	2017	}
	2018
	2019	private static class FillProcessHandler extends ProcessHandler {
	2020
	2021	FillData fd;
	2022
	2023	/* Note: For more easy reading of the code below each java version of
	2024	* the macros from the ProcessPath.c preceded by the commented
	2025	* origin call containing verbose names of the parameters
	2026	*/
	2027	public void processFixedLine(int x1, int y1, int x2, int y2,
	2028	int[] pixelInfo, boolean checkBounds,
	2029	boolean endSubPath)
	2030	{
	2031	int outXMin, outXMax, outYMin, outYMax;
	2032	int res;
	2033
	2034	/* There is no need to round line coordinates to the forward
	2035	* differencing precision anymore. Such a rounding was used for
	2036	* preventing the curve go out the endpoint (this sometimes does
	2037	* not help). The problem was fixed in the forward differencing
	2038	* loops.
	2039	*/
	2040	if (checkBounds) {
	2041	boolean lastClipped;
	2042
	2043	/* This function is used only for filling shapes, so there is no
	2044	* check for the type of clipping
	2045	*/
	2046	int c[] = new int[]{x1, y1, x2, y2, 0, 0};
	2047	outXMin = (int)(dhnd.xMinf * MDP_MULT);
	2048	outXMax = (int)(dhnd.xMaxf * MDP_MULT);
	2049	outYMin = (int)(dhnd.yMinf * MDP_MULT);
	2050	outYMax = (int)(dhnd.yMaxf * MDP_MULT);
	2051
	2052	/*
	2053	* TESTANDCLIP(outYMin, outYMax, y1, x1, y2, x2, res);
	2054	*/
	2055	res = TESTANDCLIP(outYMin, outYMax, c, 1, 0, 3, 2);
	2056	if (res == CRES_INVISIBLE) return;
	2057
	2058	/*
	2059	* TESTANDCLIP(outYMin, outYMax, y2, x2, y1, x1, res);
	2060	*/
	2061	res = TESTANDCLIP(outYMin, outYMax, c, 3, 2, 1, 0);
	2062	if (res == CRES_INVISIBLE) return;
	2063	lastClipped = IS_CLIPPED(res);
	2064
	2065	/* Clamping starting from first vertex of the the processed
	2066	* segment
	2067	*
	2068	* CLIPCLAMP(outXMin, outXMax, x1, y1, x2, y2, x3, y3, res);
	2069	*/
	2070	res = CLIPCLAMP(outXMin, outXMax, c, 0, 1, 2, 3, 4, 5);
	2071
	2072	/* Clamping only by left boundary */
	2073	if (res == CRES_MIN_CLIPPED) {
	2074	processFixedLine(c[4], c[5], c[0], c[1], pixelInfo,
	2075	false, lastClipped);
	2076
	2077	} else if (res == CRES_INVISIBLE) {
	2078	return;
	2079	}
	2080
	2081	/* Clamping starting from last vertex of the the processed
	2082	* segment
	2083	*
	2084	* CLIPCLAMP(outXMin, outXMax, x2, y2, x1, y1, x3, y3, res);
	2085	*/
	2086	res = CLIPCLAMP(outXMin, outXMax, c, 2, 3, 0, 1, 4, 5);
	2087
	2088	/* Checking if there was a clip by right boundary */
	2089	lastClipped = lastClipped \|\| (res == CRES_MAX_CLIPPED);
	2090
	2091	processFixedLine(c[0], c[1], c[2], c[3], pixelInfo,
	2092	false, lastClipped);
	2093
	2094	/* Clamping only by left boundary */
	2095	if (res == CRES_MIN_CLIPPED) {
	2096	processFixedLine(c[2], c[3], c[4], c[5], pixelInfo,
	2097	false, lastClipped);
	2098	}
	2099
	2100	return;
	2101	}
	2102
	2103	/* Adding first point of the line only in case of empty or just
	2104	* finished path
	2105	*/
	2106	if (fd.isEmpty() \|\| fd.isEnded()) {
	2107	fd.addPoint(x1, y1, false);
	2108	}
	2109
	2110	fd.addPoint(x2, y2, false);
	2111
	2112	if (endSubPath) {
	2113	fd.setEnded();
	2114	}
	2115	}
	2116
	2117	FillProcessHandler(DrawHandler dhnd) {
	2118	super(dhnd, PH_MODE_FILL_CLIP);
	2119	this.fd = new FillData();
	2120	}
	2121
	2122	public void processEndSubPath() {
	2123	if (!fd.isEmpty()) {
	2124	fd.setEnded();
	2125	}
	2126	}
	2127	}
	2128	}

java/pkg/sun/java2d/loops/RenderCache$Entry.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/RenderCache.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/RenderCache.java+103−0

@@ -0,0 +1,103 @@
	1	/*
	2	* Copyright (c) 1999, 2004, 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.loops;
	27
	28	public final class RenderCache {
	29	final class Entry {
	30	private SurfaceType src;
	31	private CompositeType comp;
	32	private SurfaceType dst;
	33	private Object value;
	34
	35	public Entry(SurfaceType src,
	36	CompositeType comp,
	37	SurfaceType dst,
	38	Object value)
	39	{
	40	this.src = src;
	41	this.comp = comp;
	42	this.dst = dst;
	43	this.value = value;
	44	}
	45
	46	public boolean matches(SurfaceType src,
	47	CompositeType comp,
	48	SurfaceType dst)
	49	{
	50	// bug 4725045: using equals() causes different SurfaceType
	51	// objects with the same strings to match in the cache, which is
	52	// not the behavior we want. Constrain the match to succeed only
	53	// on object matches instead.
	54	return ((this.src == src) &&
	55	(this.comp == comp) &&
	56	(this.dst == dst));
	57	}
	58
	59	public Object getValue() {
	60	return value;
	61	}
	62	}
	63
	64	private Entry entries[];
	65
	66	public RenderCache(int size) {
	67	entries = new Entry[size];
	68	}
	69
	70	public synchronized Object get(SurfaceType src,
	71	CompositeType comp,
	72	SurfaceType dst)
	73	{
	74	int max = entries.length - 1;
	75	for (int i = max; i >= 0; i--) {
	76	Entry e = entries[i];
	77	if (e == null) {
	78	break;
	79	}
	80	if (e.matches(src, comp, dst)) {
	81	if (i < max - 4) {
	82	System.arraycopy(entries, i+1, entries, i, max - i);
	83	entries[max] = e;
	84	}
	85	return e.getValue();
	86	}
	87	}
	88
	89	return null;
	90	}
	91
	92	public synchronized void put(SurfaceType src,
	93	CompositeType comp,
	94	SurfaceType dst,
	95	Object value)
	96	{
	97	Entry e = new Entry(src, comp, dst, value);
	98
	99	int num = entries.length;
	100	System.arraycopy(entries, 1, entries, 0, num - 1);
	101	entries[num - 1] = e;
	102	}
	103	}

java/pkg/sun/java2d/loops/RenderLoops.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/RenderLoops.java+55−0

@@ -0,0 +1,55 @@
	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.loops;
	27
	28	/*
	29	* This class stores the various loops that are used by the
	30	* standard rendering pipelines. The loops for a given instance
	31	* of this class will all share the same destination type and the
	32	* same supported paint and composite operation.
	33	* Each instance of this class should be shared by all graphics
	34	* objects that render onto the same type of destination with the
	35	* same paint and composite combination to reduce the amount of
	36	* time spent looking up loops appropriate for the current fill
	37	* technique.
	38	*/
	39	public class RenderLoops {
	40
	41	public static final int primTypeID = GraphicsPrimitive.makePrimTypeID();
	42
	43	public DrawLine drawLineLoop;
	44	public FillRect fillRectLoop;
	45	public DrawRect drawRectLoop;
	46	public DrawPolygons drawPolygonsLoop;
	47	public DrawPath drawPathLoop;
	48	public FillPath fillPathLoop;
	49	public FillSpans fillSpansLoop;
	50	public FillParallelogram fillParallelogramLoop;
	51	public DrawParallelogram drawParallelogramLoop;
	52	public DrawGlyphList drawGlyphListLoop;
	53	public DrawGlyphListAA drawGlyphListAALoop;
	54	public DrawGlyphListLCD drawGlyphListLCDLoop;
	55	}

java/pkg/sun/java2d/loops/ScaledBlit$TraceScaledBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ScaledBlit.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/ScaledBlit.java+156−0

@@ -0,0 +1,156 @@
	1	/*
	2	* Copyright (c) 2001, 2004, 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.loops;
	27
	28	import java.awt.Composite;
	29	import java.lang.ref.WeakReference;
	30	import sun.java2d.loops.GraphicsPrimitive;
	31	import sun.java2d.SurfaceData;
	32	import sun.java2d.pipe.Region;
	33
	34	/**
	35	* ScaledBlit
	36	* 1) copies rectangle of pixels from one surface to another
	37	* while scaling the pixels to meet the sizes specified
	38	* 2) performs compositing of colors based upon a Composite
	39	* parameter
	40	*
	41	* precise behavior is undefined if the source surface
	42	* and the destination surface are the same surface
	43	* with overlapping regions of pixels
	44	*/
	45
	46	public class ScaledBlit extends GraphicsPrimitive
	47	{
	48	public static final String methodSignature = "ScaledBlit(...)".toString();
	49
	50	public static final int primTypeID = makePrimTypeID();
	51
	52	private static RenderCache blitcache = new RenderCache(20);
	53
	54	public static ScaledBlit locate(SurfaceType srctype,
	55	CompositeType comptype,
	56	SurfaceType dsttype)
	57	{
	58	return (ScaledBlit)
	59	GraphicsPrimitiveMgr.locate(primTypeID,
	60	srctype, comptype, dsttype);
	61	}
	62
	63	public static ScaledBlit getFromCache(SurfaceType src,
	64	CompositeType comp,
	65	SurfaceType dst)
	66	{
	67	Object o = blitcache.get(src, comp, dst);
	68	if (o != null) {
	69	return (ScaledBlit) o;
	70	}
	71	ScaledBlit blit = locate(src, comp, dst);
	72	if (blit == null) {
	73	/*
	74	System.out.println("blit loop not found for:");
	75	System.out.println("src: "+src);
	76	System.out.println("comp: "+comp);
	77	System.out.println("dst: "+dst);
	78	*/
	79	} else {
	80	blitcache.put(src, comp, dst, blit);
	81	}
	82	return blit;
	83	}
	84
	85	protected ScaledBlit(SurfaceType srctype,
	86	CompositeType comptype,
	87	SurfaceType dsttype)
	88	{
	89	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	90	}
	91
	92	public ScaledBlit(long pNativePrim,
	93	SurfaceType srctype,
	94	CompositeType comptype,
	95	SurfaceType dsttype)
	96	{
	97	super(pNativePrim, methodSignature, primTypeID,
	98	srctype, comptype, dsttype);
	99	}
	100
	101	public native void Scale(SurfaceData src, SurfaceData dst,
	102	Composite comp, Region clip,
	103	int sx1, int sy1,
	104	int sx2, int sy2,
	105	double dx1, double dy1,
	106	double dx2, double dy2);
	107
	108	static {
	109	GraphicsPrimitiveMgr.registerGeneral(new ScaledBlit(null, null, null));
	110	}
	111
	112	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	113	CompositeType comptype,
	114	SurfaceType dsttype)
	115	{
	116	/*
	117	System.out.println("Constructing general blit for:");
	118	System.out.println("src: "+srctype);
	119	System.out.println("comp: "+comptype);
	120	System.out.println("dst: "+dsttype);
	121	*/
	122	return null;
	123	}
	124
	125	public GraphicsPrimitive traceWrap() {
	126	return new TraceScaledBlit(this);
	127	}
	128
	129	private static class TraceScaledBlit extends ScaledBlit {
	130	ScaledBlit target;
	131
	132	public TraceScaledBlit(ScaledBlit target) {
	133	super(target.getSourceType(),
	134	target.getCompositeType(),
	135	target.getDestType());
	136	this.target = target;
	137	}
	138
	139	public GraphicsPrimitive traceWrap() {
	140	return this;
	141	}
	142
	143	public void Scale(SurfaceData src, SurfaceData dst,
	144	Composite comp, Region clip,
	145	int sx1, int sy1,
	146	int sx2, int sy2,
	147	double dx1, double dy1,
	148	double dx2, double dy2)
	149	{
	150	tracePrimitive(target);
	151	target.Scale(src, dst, comp, clip,
	152	sx1, sy1, sx2, sy2,
	153	dx1, dy1, dx2, dy2);
	154	}
	155	}
	156	}

java/pkg/sun/java2d/loops/SetDrawLineANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SetDrawPathANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SetDrawPolygonsANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SetDrawRectANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SetFillPathANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SetFillRectANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SetFillSpansANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SolidPixelWriter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SurfaceType.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/SurfaceType.java+460−0

@@ -0,0 +1,460 @@
	1	/*
	2	* Copyright (c) 1999, 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.loops;
	27
	28	import java.awt.image.BufferedImage;
	29	import java.awt.image.ColorModel;
	30	import sun.awt.image.PixelConverter;
	31	import java.util.HashMap;
	32
	33	/**
	34	* A SurfaceType object provides a chained description of a type of
	35	* drawing surface. The object will provide a single String constant
	36	* descriptor which is one way of viewing or accessing a particular
	37	* drawing surface as well as a pointer to another SurfaceType which
	38	* describes the same drawing surface in a different (typically more
	39	* generalized) way.
	40	* <p>
	41	* A more specific description of a surface is considered a "subtype"
	42	* and a more general description is considered a "supertype". Thus,
	43	* the deriveSubType method provides a way to create a new SurfaceType
	44	* that is related to but more specific than an existing SurfaceType and
	45	* the getSuperType method provides a way to ask a given SurfaceType
	46	* for a more general way to describe the same surface.
	47	* <p>
	48	* Note that you cannot construct a brand new root for a chain since
	49	* the constructor is private. Every chain of types must at some point
	50	* derive from the Any node provided here using the deriveSubType()
	51	* method. The presence of this common Any node on every chain
	52	* ensures that all chains end with the DESC_ANY descriptor so that
	53	* a suitable General GraphicsPrimitive object can be obtained for
	54	* the indicated surface if all of the more specific searches fail.
	55	*/
	56	public final class SurfaceType {
	57
	58	private static int unusedUID = 1;
	59	private static HashMap surfaceUIDMap = new HashMap(100);
	60
	61	/*
	62	* CONSTANTS USED BY ALL PRIMITIVES TO DESCRIBE THE SURFACES
	63	* THEY CAN OPERATE ON
	64	*/
	65
	66	/**
	67	* surface is unknown color model or sample model.
	68	*/
	69	public static final String
	70	DESC_ANY = "Any Surface";
	71
	72	/**
	73	* common surface formats defined in BufferedImage
	74	*/
	75	public static final String
	76	DESC_INT_RGB = "Integer RGB";
	77	public static final String
	78	DESC_INT_ARGB = "Integer ARGB";
	79	public static final String
	80	DESC_INT_ARGB_PRE = "Integer ARGB Premultiplied";
	81	public static final String
	82	DESC_INT_BGR = "Integer BGR";
	83	public static final String
	84	DESC_3BYTE_BGR = "3 Byte BGR";
	85	public static final String
	86	DESC_4BYTE_ABGR = "4 Byte ABGR";
	87	public static final String
	88	DESC_4BYTE_ABGR_PRE = "4 Byte ABGR Premultiplied";
	89	public static final String
	90	DESC_USHORT_565_RGB = "Short 565 RGB";
	91	public static final String
	92	DESC_USHORT_555_RGB = "Short 555 RGB";
	93	public static final String
	94	DESC_USHORT_555_RGBx= "Short 555 RGBx";
	95	public static final String
	96	DESC_USHORT_4444_ARGB= "Short 4444 ARGB";
	97	public static final String
	98	DESC_BYTE_GRAY = "8-bit Gray";
	99	public static final String
	100	DESC_USHORT_INDEXED = "16-bit Indexed";
	101	public static final String
	102	DESC_USHORT_GRAY = "16-bit Gray";
	103	public static final String
	104	DESC_BYTE_BINARY = "Packed Binary Bitmap";
	105	public static final String
	106	DESC_BYTE_INDEXED = "8-bit Indexed";
	107
	108	/**
	109	* wildcard format which indicates that the GraphicsPrimitive
	110	* is independent of the color model on an IntegerComponent
	111	* sample model surface
	112	*/
	113	public static final String DESC_ANY_INT = "Any Discrete Integer";
	114
	115	/**
	116	* wildcard format which indicates that the GraphicsPrimitive
	117	* is independent of the color model on a ShortComponent
	118	* sample model surface
	119	*/
	120	public static final String DESC_ANY_SHORT = "Any Discrete Short";
	121
	122	/**
	123	* wildcard format which indicates that the GraphicsPrimitive
	124	* is independent of the color model on a ByteComponent
	125	* sample model surface
	126	*/
	127	public static final String DESC_ANY_BYTE = "Any Discrete Byte";
	128
	129	/**
	130	* wildcard format which indicates that the GraphicsPrimitive
	131	* operates on a surface with 3 component interleaved Raster and
	132	* sample model and a ComponentColorModel with an arbitrary ordering
	133	* of the RGB channels
	134	*/
	135	public static final String DESC_ANY_3BYTE = "Any 3 Byte Component";
	136
	137	/**
	138	* wildcard format which indicates that the GraphicsPrimitive
	139	* operates on a surface with 4 component interleaved Raster and
	140	* sample model and a ComponentColorModel with an arbitrary ordering
	141	* of the ARGB channels
	142	*/
	143	public static final String DESC_ANY_4BYTE = "Any 4 Byte Component";
	144
	145	/**
	146	* wildcard format which indicates that the GraphicsPrimitive
	147	* operates on a surface with a single component IntegerComponent
	148	* sample model and a DirectColorModel with an arbitrary ordering
	149	* of the RGB channels
	150	*/
	151	public static final String DESC_ANY_INT_DCM = "Any Integer DCM";
	152
	153	/**
	154	* additional IntegerComponent types common on Windows
	155	*/
	156	public static final String DESC_INT_RGBx = "Integer RGBx";
	157	public static final String DESC_INT_BGRx = "Integer BGRx";
	158
	159	/**
	160	* additional 3 byte format common on Windows
	161	*/
	162	public static final String DESC_3BYTE_RGB = "3 Byte RGB";
	163
	164	/**
	165	* common formats for BITMASK transparency.
	166	*/
	167	public static final String DESC_INT_ARGB_BM = "Int ARGB (Bitmask)";
	168	public static final String DESC_BYTE_INDEXED_BM = "8-bit Indexed (Bitmask)";
	169
	170	/**
	171	* Opaque 8-bit indexed images
	172	*/
	173	public static final String
	174	DESC_BYTE_INDEXED_OPAQUE = "8-bit Indexed (Opaque)";
	175
	176	/**
	177	* Special Gray Scale types for rendering loops. Really indexed
	178	* types, but colormap has all gray values.
	179	*/
	180	public static final String DESC_INDEX8_GRAY = "8-bit Palettized Gray";
	181	public static final String DESC_INDEX12_GRAY = "12-bit Palettized Gray";
	182
	183	public static final String
	184	DESC_BYTE_BINARY_1BIT = "Packed Binary 1-bit Bitmap";
	185	public static final String
	186	DESC_BYTE_BINARY_2BIT = "Packed Binary 2-bit Bitmap";
	187	public static final String
	188	DESC_BYTE_BINARY_4BIT = "Packed Binary 4-bit Bitmap";
	189
	190	/**
	191	* Special type for describing the sources of loops that render the
	192	* current foreground color or paint instead of copying colors from
	193	* a source surface.
	194	*/
	195	public static final String DESC_ANY_PAINT = "Paint Object";
	196	public static final String DESC_ANY_COLOR = "Single Color";
	197	public static final String DESC_OPAQUE_COLOR = "Opaque Color";
	198	public static final String
	199	DESC_GRADIENT_PAINT = "Gradient Paint";
	200	public static final String
	201	DESC_OPAQUE_GRADIENT_PAINT = "Opaque Gradient Paint";
	202	public static final String
	203	DESC_TEXTURE_PAINT = "Texture Paint";
	204	public static final String
	205	DESC_OPAQUE_TEXTURE_PAINT = "Opaque Texture Paint";
	206	public static final String
	207	DESC_LINEAR_GRADIENT_PAINT = "Linear Gradient Paint";
	208	public static final String
	209	DESC_OPAQUE_LINEAR_GRADIENT_PAINT = "Opaque Linear Gradient Paint";
	210	public static final String
	211	DESC_RADIAL_GRADIENT_PAINT = "Radial Gradient Paint";
	212	public static final String
	213	DESC_OPAQUE_RADIAL_GRADIENT_PAINT = "Opaque Radial Gradient Paint";
	214
	215	/*
	216	* END OF SURFACE TYPE CONSTANTS
	217	*/
	218
	219
	220	/**
	221	* The root SurfaceType object for all chains of surface descriptions.
	222	* The root uses the default PixelConverter object, which uses a given
	223	* ColorModel object to calculate its pixelFor() values when asked.
	224	* Any SurfaceType objects that are not created with a specific
	225	* PixelConverter object will inherit this behavior from the root.
	226	*/
	227	public static final SurfaceType Any =
	228	new SurfaceType(null, DESC_ANY, PixelConverter.instance);
	229
	230	/*
	231	* START OF SurfaceType OBJECTS FOR THE VARIOUS CONSTANTS
	232	*/
	233
	234	public static final SurfaceType
	235	AnyInt = Any.deriveSubType(DESC_ANY_INT);
	236	public static final SurfaceType
	237	AnyShort = Any.deriveSubType(DESC_ANY_SHORT);
	238	public static final SurfaceType
	239	AnyByte = Any.deriveSubType(DESC_ANY_BYTE);
	240	public static final SurfaceType
	241	AnyByteBinary = Any.deriveSubType(DESC_BYTE_BINARY);
	242	public static final SurfaceType
	243	Any3Byte = Any.deriveSubType(DESC_ANY_3BYTE);
	244	public static final SurfaceType
	245	Any4Byte = Any.deriveSubType(DESC_ANY_4BYTE);
	246	public static final SurfaceType
	247	AnyDcm = AnyInt.deriveSubType(DESC_ANY_INT_DCM);
	248
	249	public static final SurfaceType
	250	Custom = Any;
	251	public static final SurfaceType IntRgb =
	252	AnyDcm.deriveSubType(DESC_INT_RGB, PixelConverter.Xrgb.instance);
	253
	254	public static final SurfaceType IntArgb =
	255	AnyDcm.deriveSubType(DESC_INT_ARGB, PixelConverter.Argb.instance);
	256
	257	public static final SurfaceType IntArgbPre =
	258	AnyDcm.deriveSubType(DESC_INT_ARGB_PRE,
	259	PixelConverter.ArgbPre.instance);
	260
	261	public static final SurfaceType IntBgr =
	262	AnyDcm.deriveSubType(DESC_INT_BGR, PixelConverter.Xbgr.instance);
	263
	264	public static final SurfaceType ThreeByteBgr =
	265	Any3Byte.deriveSubType(DESC_3BYTE_BGR, PixelConverter.Xrgb.instance);
	266
	267	public static final SurfaceType FourByteAbgr =
	268	Any4Byte.deriveSubType(DESC_4BYTE_ABGR, PixelConverter.Rgba.instance);
	269
	270	public static final SurfaceType FourByteAbgrPre =
	271	Any4Byte.deriveSubType(DESC_4BYTE_ABGR_PRE,
	272	PixelConverter.RgbaPre.instance);
	273
	274	public static final SurfaceType Ushort565Rgb =
	275	AnyShort.deriveSubType(DESC_USHORT_565_RGB,
	276	PixelConverter.Ushort565Rgb.instance);
	277
	278	public static final SurfaceType Ushort555Rgb =
	279	AnyShort.deriveSubType(DESC_USHORT_555_RGB,
	280	PixelConverter.Ushort555Rgb.instance);
	281
	282	public static final SurfaceType Ushort555Rgbx =
	283	AnyShort.deriveSubType(DESC_USHORT_555_RGBx,
	284	PixelConverter.Ushort555Rgbx.instance);
	285
	286	public static final SurfaceType Ushort4444Argb =
	287	AnyShort.deriveSubType(DESC_USHORT_4444_ARGB,
	288	PixelConverter.Ushort4444Argb.instance);
	289
	290	public static final SurfaceType UshortIndexed =
	291	AnyShort.deriveSubType(DESC_USHORT_INDEXED);
	292
	293	public static final SurfaceType ByteGray =
	294	AnyByte.deriveSubType(DESC_BYTE_GRAY,
	295	PixelConverter.ByteGray.instance);
	296
	297	public static final SurfaceType UshortGray =
	298	AnyShort.deriveSubType(DESC_USHORT_GRAY,
	299	PixelConverter.UshortGray.instance);
	300
	301	public static final SurfaceType ByteBinary1Bit =
	302	AnyByteBinary.deriveSubType(DESC_BYTE_BINARY_1BIT);
	303	public static final SurfaceType ByteBinary2Bit =
	304	AnyByteBinary.deriveSubType(DESC_BYTE_BINARY_2BIT);
	305	public static final SurfaceType ByteBinary4Bit =
	306	AnyByteBinary.deriveSubType(DESC_BYTE_BINARY_4BIT);
	307
	308	public static final SurfaceType ByteIndexed =
	309	AnyByte.deriveSubType(DESC_BYTE_INDEXED);
	310
	311	public static final SurfaceType IntRgbx =
	312	AnyDcm.deriveSubType(DESC_INT_RGBx, PixelConverter.Rgbx.instance);
	313
	314	public static final SurfaceType IntBgrx =
	315	AnyDcm.deriveSubType(DESC_INT_BGRx, PixelConverter.Bgrx.instance);
	316
	317	public static final SurfaceType ThreeByteRgb =
	318	Any3Byte.deriveSubType(DESC_3BYTE_RGB, PixelConverter.Xbgr.instance);
	319
	320	public static final SurfaceType IntArgbBm =
	321	AnyDcm.deriveSubType(DESC_INT_ARGB_BM, PixelConverter.ArgbBm.instance);
	322
	323	public static final SurfaceType ByteIndexedBm =
	324	ByteIndexed.deriveSubType(DESC_BYTE_INDEXED_BM);
	325
	326	public static final SurfaceType ByteIndexedOpaque =
	327	ByteIndexedBm.deriveSubType(DESC_BYTE_INDEXED_OPAQUE);
	328
	329	public static final SurfaceType Index8Gray =
	330	ByteIndexedOpaque.deriveSubType(DESC_INDEX8_GRAY);
	331
	332	public static final SurfaceType Index12Gray =
	333	Any.deriveSubType(DESC_INDEX12_GRAY);
	334
	335	public static final SurfaceType AnyPaint =
	336	Any.deriveSubType(DESC_ANY_PAINT);
	337
	338	public static final SurfaceType AnyColor =
	339	AnyPaint.deriveSubType(DESC_ANY_COLOR);
	340
	341	public static final SurfaceType OpaqueColor =
	342	AnyColor.deriveSubType(DESC_OPAQUE_COLOR);
	343
	344	public static final SurfaceType GradientPaint =
	345	AnyPaint.deriveSubType(DESC_GRADIENT_PAINT);
	346	public static final SurfaceType OpaqueGradientPaint =
	347	GradientPaint.deriveSubType(DESC_OPAQUE_GRADIENT_PAINT);
	348
	349	public static final SurfaceType LinearGradientPaint =
	350	AnyPaint.deriveSubType(DESC_LINEAR_GRADIENT_PAINT);
	351	public static final SurfaceType OpaqueLinearGradientPaint =
	352	LinearGradientPaint.deriveSubType(DESC_OPAQUE_LINEAR_GRADIENT_PAINT);
	353
	354	public static final SurfaceType RadialGradientPaint =
	355	AnyPaint.deriveSubType(DESC_RADIAL_GRADIENT_PAINT);
	356	public static final SurfaceType OpaqueRadialGradientPaint =
	357	RadialGradientPaint.deriveSubType(DESC_OPAQUE_RADIAL_GRADIENT_PAINT);
	358
	359	public static final SurfaceType TexturePaint =
	360	AnyPaint.deriveSubType(DESC_TEXTURE_PAINT);
	361	public static final SurfaceType OpaqueTexturePaint =
	362	TexturePaint.deriveSubType(DESC_OPAQUE_TEXTURE_PAINT);
	363
	364	/*
	365	* END OF SurfaceType OBJECTS FOR THE VARIOUS CONSTANTS
	366	*/
	367
	368	/**
	369	* Return a new SurfaceType object which uses this object as its
	370	* more general "supertype" descriptor. If no operation can be
	371	* found that manipulates the type of surface described more exactly
	372	* by desc, then this object will define the more relaxed specification
	373	* of the surface that can be used to find a more general operator.
	374	*/
	375	public SurfaceType deriveSubType(String desc) {
	376	return new SurfaceType(this, desc);
	377	}
	378
	379	public SurfaceType deriveSubType(String desc,
	380	PixelConverter pixelConverter) {
	381	return new SurfaceType(this, desc, pixelConverter);
	382	}
	383
	384	private int uniqueID;
	385	private String desc;
	386	private SurfaceType next;
	387	protected PixelConverter pixelConverter;
	388
	389	private SurfaceType(SurfaceType parent, String desc,
	390	PixelConverter pixelConverter) {
	391	next = parent;
	392	this.desc = desc;
	393	this.uniqueID = makeUniqueID(desc);
	394	this.pixelConverter = pixelConverter;
	395	}
	396
	397	private SurfaceType(SurfaceType parent, String desc) {
	398	next = parent;
	399	this.desc = desc;
	400	this.uniqueID = makeUniqueID(desc);
	401	this.pixelConverter = parent.pixelConverter;
	402	}
	403
	404	public synchronized static final int makeUniqueID(String desc) {
	405	Integer i = (Integer) surfaceUIDMap.get((Object) desc);
	406
	407	if (i == null) {
	408	if (unusedUID > 255) {
	409	throw new InternalError("surface type id overflow");
	410	}
	411	i = Integer.valueOf(unusedUID++);
	412	surfaceUIDMap.put(desc, i);
	413	}
	414	return i.intValue();
	415	}
	416
	417	public int getUniqueID() {
	418	return uniqueID;
	419	}
	420
	421	public String getDescriptor() {
	422	return desc;
	423	}
	424
	425	public SurfaceType getSuperType() {
	426	return next;
	427	}
	428
	429	public PixelConverter getPixelConverter() {
	430	return pixelConverter;
	431	}
	432
	433	public int pixelFor(int rgb, ColorModel cm) {
	434	return pixelConverter.rgbToPixel(rgb, cm);
	435	}
	436
	437	public int rgbFor(int pixel, ColorModel cm) {
	438	return pixelConverter.pixelToRgb(pixel, cm);
	439	}
	440
	441	public int getAlphaMask() {
	442	return pixelConverter.getAlphaMask();
	443	}
	444
	445	public int hashCode() {
	446	return desc.hashCode();
	447	}
	448
	449	public boolean equals(Object o) {
	450	if (o instanceof SurfaceType) {
	451	return (((SurfaceType) o).uniqueID == this.uniqueID);
	452	}
	453	return false;
	454	}
	455
	456	public String toString() {
	457	return desc;
	458	}
	459
	460	}

java/pkg/sun/java2d/loops/TransformBlit.java+157−0

@@ -0,0 +1,157 @@
	1	/*
	2	* Copyright (c) 2003, 2004, 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.loops;
	27
	28	import java.awt.Composite;
	29	import java.awt.geom.AffineTransform;
	30	import java.lang.ref.WeakReference;
	31	import sun.java2d.SurfaceData;
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import sun.java2d.pipe.Region;
	34
	35	/**
	36	* TransformBlit
	37	* 1) applies an AffineTransform to a rectangle of pixels while copying
	38	* from one surface to another
	39	* 2) performs compositing of colors based upon a Composite
	40	* parameter
	41	*
	42	* precise behavior is undefined if the source surface
	43	* and the destination surface are the same surface
	44	* with overlapping regions of pixels
	45	*/
	46
	47	public class TransformBlit extends GraphicsPrimitive
	48	{
	49	public static final String methodSignature =
	50	"TransformBlit(...)".toString();
	51
	52	public static final int primTypeID = makePrimTypeID();
	53
	54	private static RenderCache blitcache = new RenderCache(10);
	55
	56	public static TransformBlit locate(SurfaceType srctype,
	57	CompositeType comptype,
	58	SurfaceType dsttype)
	59	{
	60	return (TransformBlit)
	61	GraphicsPrimitiveMgr.locate(primTypeID,
	62	srctype, comptype, dsttype);
	63	}
	64
	65	public static TransformBlit getFromCache(SurfaceType src,
	66	CompositeType comp,
	67	SurfaceType dst)
	68	{
	69	Object o = blitcache.get(src, comp, dst);
	70	if (o != null) {
	71	return (TransformBlit) o;
	72	}
	73	TransformBlit blit = locate(src, comp, dst);
	74	if (blit == null) {
	75	/*
	76	System.out.println("blit loop not found for:");
	77	System.out.println("src: "+src);
	78	System.out.println("comp: "+comp);
	79	System.out.println("dst: "+dst);
	80	*/
	81	} else {
	82	blitcache.put(src, comp, dst, blit);
	83	}
	84	return blit;
	85	}
	86
	87	protected TransformBlit(SurfaceType srctype,
	88	CompositeType comptype,
	89	SurfaceType dsttype)
	90	{
	91	super(methodSignature, primTypeID, srctype, comptype, dsttype);
	92	}
	93
	94	public TransformBlit(long pNativePrim,
	95	SurfaceType srctype,
	96	CompositeType comptype,
	97	SurfaceType dsttype)
	98	{
	99	super(pNativePrim, methodSignature, primTypeID,
	100	srctype, comptype, dsttype);
	101	}
	102
	103	public native void Transform(SurfaceData src, SurfaceData dst,
	104	Composite comp, Region clip,
	105	AffineTransform at, int hint,
	106	int srcx, int srcy, int dstx, int dsty,
	107	int width, int height);
	108
	109	// REMIND: do we have a general loop?
	110	static {
	111	GraphicsPrimitiveMgr.registerGeneral(new TransformBlit(null, null,
	112	null));
	113	}
	114
	115	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	116	CompositeType comptype,
	117	SurfaceType dsttype)
	118	{
	119	/*
	120	System.out.println("Constructing general blit for:");
	121	System.out.println("src: "+srctype);
	122	System.out.println("comp: "+comptype);
	123	System.out.println("dst: "+dsttype);
	124	*/
	125	return null;
	126	}
	127
	128	public GraphicsPrimitive traceWrap() {
	129	return new TraceTransformBlit(this);
	130	}
	131
	132	private static class TraceTransformBlit extends TransformBlit {
	133	TransformBlit target;
	134
	135	public TraceTransformBlit(TransformBlit target) {
	136	super(target.getSourceType(),
	137	target.getCompositeType(),
	138	target.getDestType());
	139	this.target = target;
	140	}
	141
	142	public GraphicsPrimitive traceWrap() {
	143	return this;
	144	}
	145
	146	public void Transform(SurfaceData src, SurfaceData dst,
	147	Composite comp, Region clip,
	148	AffineTransform at, int hint,
	149	int srcx, int srcy, int dstx, int dsty,
	150	int width, int height)
	151	{
	152	tracePrimitive(target);
	153	target.Transform(src, dst, comp, clip, at, hint,
	154	srcx, srcy, dstx, dsty, width, height);
	155	}
	156	}
	157	}

java/pkg/sun/java2d/loops/TransformHelper$TraceTransformHelper.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/TransformHelper.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/TransformHelper.java+140−0

@@ -0,0 +1,140 @@
	1	/*
	2	* Copyright (c) 2004, 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.loops;
	27
	28	import java.awt.Composite;
	29	import java.awt.geom.AffineTransform;
	30	import java.lang.ref.WeakReference;
	31	import sun.java2d.SurfaceData;
	32	import sun.java2d.loops.GraphicsPrimitive;
	33	import sun.java2d.pipe.Region;
	34
	35	/**
	36	* TransformHelper
	37	* 1) applies an AffineTransform to a rectangle of pixels while copying
	38	* from one surface to another
	39	* 2) performs compositing of colors based upon a Composite
	40	* parameter
	41	*
	42	* precise behavior is undefined if the source surface
	43	* and the destination surface are the same surface
	44	* with overlapping regions of pixels
	45	*/
	46	public class TransformHelper extends GraphicsPrimitive
	47	{
	48	public static final String methodSignature =
	49	"TransformHelper(...)".toString();
	50
	51	public static final int primTypeID = makePrimTypeID();
	52
	53	private static RenderCache helpercache = new RenderCache(10);
	54
	55	public static TransformHelper locate(SurfaceType srctype) {
	56	return (TransformHelper)
	57	GraphicsPrimitiveMgr.locate(primTypeID,
	58	srctype,
	59	CompositeType.SrcNoEa,
	60	SurfaceType.IntArgbPre);
	61	}
	62
	63	public static synchronized TransformHelper getFromCache(SurfaceType src) {
	64	Object o = helpercache.get(src, null, null);
	65	if (o != null) {
	66	return (TransformHelper) o;
	67	}
	68	TransformHelper helper = locate(src);
	69	if (helper == null) {
	70	/*
	71	System.out.println("helper loop not found for:");
	72	System.out.println("src: "+src);
	73	*/
	74	} else {
	75	helpercache.put(src, null, null, helper);
	76	}
	77	return helper;
	78	}
	79
	80	protected TransformHelper(SurfaceType srctype) {
	81	super(methodSignature, primTypeID, srctype,
	82	CompositeType.SrcNoEa,
	83	SurfaceType.IntArgbPre);
	84	}
	85
	86	public TransformHelper(long pNativePrim, SurfaceType srctype,
	87	CompositeType comptype,
	88	SurfaceType dsttype)
	89	{
	90	super(pNativePrim, methodSignature, primTypeID,
	91	srctype, comptype, dsttype);
	92	}
	93
	94	public native void Transform(MaskBlit output,
	95	SurfaceData src, SurfaceData dst,
	96	Composite comp, Region clip,
	97	AffineTransform itx, int txtype,
	98	int sx1, int sy1, int sx2, int sy2,
	99	int dx1, int dy1, int dx2, int dy2,
	100	int edges[], int dxoff, int dyoff);
	101
	102	public GraphicsPrimitive makePrimitive(SurfaceType srctype,
	103	CompositeType comptype,
	104	SurfaceType dsttype)
	105	{
	106	return null;
	107	}
	108
	109	public GraphicsPrimitive traceWrap() {
	110	return new TraceTransformHelper(this);
	111	}
	112
	113	private static class TraceTransformHelper extends TransformHelper {
	114	TransformHelper target;
	115
	116	public TraceTransformHelper(TransformHelper target) {
	117	super(target.getSourceType());
	118	this.target = target;
	119	}
	120
	121	public GraphicsPrimitive traceWrap() {
	122	return this;
	123	}
	124
	125	public void Transform(MaskBlit output,
	126	SurfaceData src, SurfaceData dst,
	127	Composite comp, Region clip,
	128	AffineTransform itx, int txtype,
	129	int sx1, int sy1, int sx2, int sy2,
	130	int dx1, int dy1, int dx2, int dy2,
	131	int edges[], int dxoff, int dyoff)
	132	{
	133	tracePrimitive(target);
	134	target.Transform(output, src, dst, comp, clip, itx, txtype,
	135	sx1, sy1, sx2, sy2,
	136	dx1, dy1, dx2, dy2,
	137	edges, dxoff, dyoff);
	138	}
	139	}
	140	}

java/pkg/sun/java2d/loops/XORComposite.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XORComposite.java+72−0

@@ -0,0 +1,72 @@
	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.loops;
	27
	28	import java.awt.image.ColorModel;
	29	import java.awt.Color;
	30	import java.awt.Composite;
	31	import java.awt.CompositeContext;
	32	import java.awt.RenderingHints;
	33	import sun.java2d.SurfaceData;
	34	import sun.java2d.SunCompositeContext;
	35
	36	/**
	37	* Bitwise XOR Composite class.
	38	*/
	39
	40	public final class XORComposite implements Composite {
	41
	42	Color xorColor;
	43	int xorPixel;
	44	int alphaMask;
	45
	46	public XORComposite(Color xorColor, SurfaceData sd) {
	47	this.xorColor = xorColor;
	48
	49	SurfaceType sType = sd.getSurfaceType();
	50
	51	this.xorPixel = sd.pixelFor(xorColor.getRGB());
	52	this.alphaMask = sType.getAlphaMask();
	53	}
	54
	55	public Color getXorColor() {
	56	return xorColor;
	57	}
	58
	59	public int getXorPixel() {
	60	return xorPixel;
	61	}
	62
	63	public int getAlphaMask() {
	64	return alphaMask;
	65	}
	66
	67	public CompositeContext createContext(ColorModel srcColorModel,
	68	ColorModel dstColorModel,
	69	RenderingHints hints) {
	70	return new SunCompositeContext(this, srcColorModel, dstColorModel);
	71	}
	72	}

java/pkg/sun/java2d/loops/XorCopyArgbToAny.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorDrawGlyphListAAANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorDrawGlyphListANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorDrawLineANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorDrawPathANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorDrawPolygonsANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorDrawRectANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorFillPathANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorFillRectANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorFillSpansANY.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorPixelWriter$ByteData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorPixelWriter$DoubleData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorPixelWriter$FloatData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorPixelWriter$IntData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorPixelWriter$ShortData.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/XorPixelWriter.class+0−0

Binary file not shown.

java/pkg/sun/java2d/loops/mkfile+38−0

@@ -0,0 +1,38 @@
	1	<../../../../../mkconfig
	2
	3	TARG=\
	4	Blit.dis\
	5	BlitBg.dis\
	6	CompositeType.dis\
	7	CustomComponent.dis\
	8	DrawGlyphList.dis\
	9	DrawGlyphListAA.dis\
	10	DrawGlyphListLCD.dis\
	11	DrawLine.dis\
	12	DrawParallelogram.dis\
	13	DrawPath.dis\
	14	DrawPolygons.dis\
	15	DrawRect.dis\
	16	FillParallelogram.dis\
	17	FillPath.dis\
	18	FillRect.dis\
	19	FillSpans.dis\
	20	FontInfo.dis\
	21	GeneralRenderer.dis\
	22	GraphicsPrimitive.dis\
	23	GraphicsPrimitiveMgr.dis\
	24	GraphicsPrimitiveProxy.dis\
	25	MaskBlit.dis\
	26	MaskFill.dis\
	27	ProcessPath.dis\
	28	RenderCache.dis\
	29	RenderLoops.dis\
	30	ScaledBlit.dis\
	31	SurfaceType.dis\
	32	TransformBlit.dis\
	33	TransformHelper.dis\
	34	XORComposite.dis\
	35
	36	DISBIN=$ROOT/java/dis/java/java/sun/java2d/loops
	37
	38	<$ROOT/mkfiles/mkjava

java/pkg/sun/java2d/mkfile+35−0

@@ -0,0 +1,35 @@
	1	<../../../../mkconfig
	2
	3	DIRS=\
	4	cmm\
	5	loops\
	6	opengl\
	7	pipe\
	8	pisces\
	9
	10	TARG=\
	11	DefaultDisposerRecord.dis\
	12	DestSurfaceProvider.dis\
	13	Disposer.dis\
	14	DisposerRecord.dis\
	15	DisposerTarget.dis\
	16	FontSupport.dis\
	17	HeadlessGraphicsEnvironment.dis\
	18	InvalidPipeException.dis\
	19	NullSurfaceData.dis\
	20	Spans.dis\
	21	StateTrackable.dis\
	22	StateTrackableDelegate.dis\
	23	StateTracker.dis\
	24	SunCompositeContext.dis\
	25	SunGraphics2D.dis\
	26	SunGraphicsEnvironment.dis\
	27	Surface.dis\
	28	SurfaceData.dis\
	29	SurfaceDataProxy.dis\
	30	SurfaceManagerFactory.dis\
	31
	32	DISBIN=$ROOT/java/dis/java/java/sun/java2d
	33
	34	<$ROOT/mkfiles/mkjava
	35	<$ROOT/mkfiles/mksubdirs

java/pkg/sun/java2d/opengl/OGLBlitLoops.java+762−0

@@ -0,0 +1,762 @@
	1	/*
	2	* Copyright (c) 2003, 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.opengl;
	27
	28	import java.awt.Composite;
	29	import java.awt.Transparency;
	30	import java.awt.geom.AffineTransform;
	31	import java.awt.image.AffineTransformOp;
	32	import java.awt.image.BufferedImage;
	33	import java.awt.image.BufferedImageOp;
	34	import java.lang.ref.WeakReference;
	35	import sun.java2d.SurfaceData;
	36	import sun.java2d.loops.Blit;
	37	import sun.java2d.loops.CompositeType;
	38	import sun.java2d.loops.GraphicsPrimitive;
	39	import sun.java2d.loops.GraphicsPrimitiveMgr;
	40	import sun.java2d.loops.ScaledBlit;
	41	import sun.java2d.loops.SurfaceType;
	42	import sun.java2d.loops.TransformBlit;
	43	import sun.java2d.pipe.Region;
	44	import sun.java2d.pipe.RenderBuffer;
	45	import sun.java2d.pipe.RenderQueue;
	46	import static sun.java2d.pipe.BufferedOpCodes.*;
	47
	48	class OGLBlitLoops {
	49
	50	static void register() {
	51	Blit blitIntArgbPreToSurface =
	52	new OGLSwToSurfaceBlit(SurfaceType.IntArgbPre,
	53	OGLSurfaceData.PF_INT_ARGB_PRE);
	54	Blit blitIntArgbPreToTexture =
	55	new OGLSwToTextureBlit(SurfaceType.IntArgbPre,
	56	OGLSurfaceData.PF_INT_ARGB_PRE);
	57
	58	GraphicsPrimitive[] primitives = {
	59	// surface->surface ops
	60	new OGLSurfaceToSurfaceBlit(),
	61	new OGLSurfaceToSurfaceScale(),
	62	new OGLSurfaceToSurfaceTransform(),
	63
	64	// render-to-texture surface->surface ops
	65	new OGLRTTSurfaceToSurfaceBlit(),
	66	new OGLRTTSurfaceToSurfaceScale(),
	67	new OGLRTTSurfaceToSurfaceTransform(),
	68
	69	// surface->sw ops
	70	new OGLSurfaceToSwBlit(SurfaceType.IntArgb,
	71	OGLSurfaceData.PF_INT_ARGB),
	72
	73	// sw->surface ops
	74	blitIntArgbPreToSurface,
	75	new OGLSwToSurfaceBlit(SurfaceType.IntRgb,
	76	OGLSurfaceData.PF_INT_RGB),
	77	new OGLSwToSurfaceBlit(SurfaceType.IntRgbx,
	78	OGLSurfaceData.PF_INT_RGBX),
	79	new OGLSwToSurfaceBlit(SurfaceType.IntBgr,
	80	OGLSurfaceData.PF_INT_BGR),
	81	new OGLSwToSurfaceBlit(SurfaceType.IntBgrx,
	82	OGLSurfaceData.PF_INT_BGRX),
	83	new OGLSwToSurfaceBlit(SurfaceType.ThreeByteBgr,
	84	OGLSurfaceData.PF_3BYTE_BGR),
	85	new OGLSwToSurfaceBlit(SurfaceType.Ushort565Rgb,
	86	OGLSurfaceData.PF_USHORT_565_RGB),
	87	new OGLSwToSurfaceBlit(SurfaceType.Ushort555Rgb,
	88	OGLSurfaceData.PF_USHORT_555_RGB),
	89	new OGLSwToSurfaceBlit(SurfaceType.Ushort555Rgbx,
	90	OGLSurfaceData.PF_USHORT_555_RGBX),
	91	new OGLSwToSurfaceBlit(SurfaceType.ByteGray,
	92	OGLSurfaceData.PF_BYTE_GRAY),
	93	new OGLSwToSurfaceBlit(SurfaceType.UshortGray,
	94	OGLSurfaceData.PF_USHORT_GRAY),
	95	new OGLGeneralBlit(OGLSurfaceData.OpenGLSurface,
	96	CompositeType.AnyAlpha,
	97	blitIntArgbPreToSurface),
	98
	99	new OGLSwToSurfaceScale(SurfaceType.IntRgb,
	100	OGLSurfaceData.PF_INT_RGB),
	101	new OGLSwToSurfaceScale(SurfaceType.IntRgbx,
	102	OGLSurfaceData.PF_INT_RGBX),
	103	new OGLSwToSurfaceScale(SurfaceType.IntBgr,
	104	OGLSurfaceData.PF_INT_BGR),
	105	new OGLSwToSurfaceScale(SurfaceType.IntBgrx,
	106	OGLSurfaceData.PF_INT_BGRX),
	107	new OGLSwToSurfaceScale(SurfaceType.ThreeByteBgr,
	108	OGLSurfaceData.PF_3BYTE_BGR),
	109	new OGLSwToSurfaceScale(SurfaceType.Ushort565Rgb,
	110	OGLSurfaceData.PF_USHORT_565_RGB),
	111	new OGLSwToSurfaceScale(SurfaceType.Ushort555Rgb,
	112	OGLSurfaceData.PF_USHORT_555_RGB),
	113	new OGLSwToSurfaceScale(SurfaceType.Ushort555Rgbx,
	114	OGLSurfaceData.PF_USHORT_555_RGBX),
	115	new OGLSwToSurfaceScale(SurfaceType.ByteGray,
	116	OGLSurfaceData.PF_BYTE_GRAY),
	117	new OGLSwToSurfaceScale(SurfaceType.UshortGray,
	118	OGLSurfaceData.PF_USHORT_GRAY),
	119	new OGLSwToSurfaceScale(SurfaceType.IntArgbPre,
	120	OGLSurfaceData.PF_INT_ARGB_PRE),
	121
	122	new OGLSwToSurfaceTransform(SurfaceType.IntRgb,
	123	OGLSurfaceData.PF_INT_RGB),
	124	new OGLSwToSurfaceTransform(SurfaceType.IntRgbx,
	125	OGLSurfaceData.PF_INT_RGBX),
	126	new OGLSwToSurfaceTransform(SurfaceType.IntBgr,
	127	OGLSurfaceData.PF_INT_BGR),
	128	new OGLSwToSurfaceTransform(SurfaceType.IntBgrx,
	129	OGLSurfaceData.PF_INT_BGRX),
	130	new OGLSwToSurfaceTransform(SurfaceType.ThreeByteBgr,
	131	OGLSurfaceData.PF_3BYTE_BGR),
	132	new OGLSwToSurfaceTransform(SurfaceType.Ushort565Rgb,
	133	OGLSurfaceData.PF_USHORT_565_RGB),
	134	new OGLSwToSurfaceTransform(SurfaceType.Ushort555Rgb,
	135	OGLSurfaceData.PF_USHORT_555_RGB),
	136	new OGLSwToSurfaceTransform(SurfaceType.Ushort555Rgbx,
	137	OGLSurfaceData.PF_USHORT_555_RGBX),
	138	new OGLSwToSurfaceTransform(SurfaceType.ByteGray,
	139	OGLSurfaceData.PF_BYTE_GRAY),
	140	new OGLSwToSurfaceTransform(SurfaceType.UshortGray,
	141	OGLSurfaceData.PF_USHORT_GRAY),
	142	new OGLSwToSurfaceTransform(SurfaceType.IntArgbPre,
	143	OGLSurfaceData.PF_INT_ARGB_PRE),
	144
	145	// texture->surface ops
	146	new OGLTextureToSurfaceBlit(),
	147	new OGLTextureToSurfaceScale(),
	148	new OGLTextureToSurfaceTransform(),
	149
	150	// sw->texture ops
	151	blitIntArgbPreToTexture,
	152	new OGLSwToTextureBlit(SurfaceType.IntRgb,
	153	OGLSurfaceData.PF_INT_RGB),
	154	new OGLSwToTextureBlit(SurfaceType.IntRgbx,
	155	OGLSurfaceData.PF_INT_RGBX),
	156	new OGLSwToTextureBlit(SurfaceType.IntBgr,
	157	OGLSurfaceData.PF_INT_BGR),
	158	new OGLSwToTextureBlit(SurfaceType.IntBgrx,
	159	OGLSurfaceData.PF_INT_BGRX),
	160	new OGLSwToTextureBlit(SurfaceType.ThreeByteBgr,
	161	OGLSurfaceData.PF_3BYTE_BGR),
	162	new OGLSwToTextureBlit(SurfaceType.Ushort565Rgb,
	163	OGLSurfaceData.PF_USHORT_565_RGB),
	164	new OGLSwToTextureBlit(SurfaceType.Ushort555Rgb,
	165	OGLSurfaceData.PF_USHORT_555_RGB),
	166	new OGLSwToTextureBlit(SurfaceType.Ushort555Rgbx,
	167	OGLSurfaceData.PF_USHORT_555_RGBX),
	168	new OGLSwToTextureBlit(SurfaceType.ByteGray,
	169	OGLSurfaceData.PF_BYTE_GRAY),
	170	new OGLSwToTextureBlit(SurfaceType.UshortGray,
	171	OGLSurfaceData.PF_USHORT_GRAY),
	172	new OGLGeneralBlit(OGLSurfaceData.OpenGLTexture,
	173	CompositeType.SrcNoEa,
	174	blitIntArgbPreToTexture),
	175	};
	176	GraphicsPrimitiveMgr.register(primitives);
	177	}
	178
	179	/**
	180	* The following offsets are used to pack the parameters in
	181	* createPackedParams(). (They are also used at the native level when
	182	* unpacking the params.)
	183	*/
	184	private static final int OFFSET_SRCTYPE = 16;
	185	private static final int OFFSET_HINT = 8;
	186	private static final int OFFSET_TEXTURE = 3;
	187	private static final int OFFSET_RTT = 2;
	188	private static final int OFFSET_XFORM = 1;
	189	private static final int OFFSET_ISOBLIT = 0;
	190
	191	/**
	192	* Packs the given parameters into a single int value in order to save
	193	* space on the rendering queue.
	194	*/
	195	private static int createPackedParams(boolean isoblit, boolean texture,
	196	boolean rtt, boolean xform,
	197	int hint, int srctype)
	198	{
	199	return
	200	((srctype << OFFSET_SRCTYPE) \|
	201	(hint << OFFSET_HINT ) \|
	202	((texture ? 1 : 0) << OFFSET_TEXTURE) \|
	203	((rtt ? 1 : 0) << OFFSET_RTT ) \|
	204	((xform ? 1 : 0) << OFFSET_XFORM ) \|
	205	((isoblit ? 1 : 0) << OFFSET_ISOBLIT));
	206	}
	207
	208	/**
	209	* Enqueues a BLIT operation with the given parameters. Note that the
	210	* RenderQueue lock must be held before calling this method.
	211	*/
	212	private static void enqueueBlit(RenderQueue rq,
	213	SurfaceData src, SurfaceData dst,
	214	int packedParams,
	215	int sx1, int sy1,
	216	int sx2, int sy2,
	217	double dx1, double dy1,
	218	double dx2, double dy2)
	219	{
	220	// assert rq.lock.isHeldByCurrentThread();
	221	RenderBuffer buf = rq.getBuffer();
	222	rq.ensureCapacityAndAlignment(72, 24);
	223	buf.putInt(BLIT);
	224	buf.putInt(packedParams);
	225	buf.putInt(sx1).putInt(sy1);
	226	buf.putInt(sx2).putInt(sy2);
	227	buf.putDouble(dx1).putDouble(dy1);
	228	buf.putDouble(dx2).putDouble(dy2);
	229	buf.putLong(src.getNativeOps());
	230	buf.putLong(dst.getNativeOps());
	231	}
	232
	233	static void Blit(SurfaceData srcData, SurfaceData dstData,
	234	Composite comp, Region clip,
	235	AffineTransform xform, int hint,
	236	int sx1, int sy1,
	237	int sx2, int sy2,
	238	double dx1, double dy1,
	239	double dx2, double dy2,
	240	int srctype, boolean texture)
	241	{
	242	int ctxflags = 0;
	243	if (srcData.getTransparency() == Transparency.OPAQUE) {
	244	ctxflags \|= OGLContext.SRC_IS_OPAQUE;
	245	}
	246
	247	OGLRenderQueue rq = OGLRenderQueue.getInstance();
	248	rq.lock();
	249	try {
	250	// make sure the RenderQueue keeps a hard reference to the
	251	// source (sysmem) SurfaceData to prevent it from being
	252	// disposed while the operation is processed on the QFT
	253	rq.addReference(srcData);
	254
	255	OGLSurfaceData oglDst = (OGLSurfaceData)dstData;
	256	if (texture) {
	257	// make sure we have a current context before uploading
	258	// the sysmem data to the texture object
	259	OGLGraphicsConfig gc = oglDst.getOGLGraphicsConfig();
	260	OGLContext.setScratchSurface(gc);
	261	} else {
	262	OGLContext.validateContext(oglDst, oglDst,
	263	clip, comp, xform, null, null,
	264	ctxflags);
	265	}
	266
	267	int packedParams = createPackedParams(false, texture,
	268	false, xform != null,
	269	hint, srctype);
	270	enqueueBlit(rq, srcData, dstData,
	271	packedParams,
	272	sx1, sy1, sx2, sy2,
	273	dx1, dy1, dx2, dy2);
	274
	275	// always flush immediately, since we (currently) have no means
	276	// of tracking changes to the system memory surface
	277	rq.flushNow();
	278	} finally {
	279	rq.unlock();
	280	}
	281	}
	282
	283	/**
	284	* Note: The srcImg and biop parameters are only used when invoked
	285	* from the OGLBufImgOps.renderImageWithOp() method; in all other cases,
	286	* this method can be called with null values for those two parameters,
	287	* and they will be effectively ignored.
	288	*/
	289	static void IsoBlit(SurfaceData srcData, SurfaceData dstData,
	290	BufferedImage srcImg, BufferedImageOp biop,
	291	Composite comp, Region clip,
	292	AffineTransform xform, int hint,
	293	int sx1, int sy1,
	294	int sx2, int sy2,
	295	double dx1, double dy1,
	296	double dx2, double dy2,
	297	boolean texture)
	298	{
	299	int ctxflags = 0;
	300	if (srcData.getTransparency() == Transparency.OPAQUE) {
	301	ctxflags \|= OGLContext.SRC_IS_OPAQUE;
	302	}
	303
	304	OGLRenderQueue rq = OGLRenderQueue.getInstance();
	305	rq.lock();
	306	try {
	307	OGLSurfaceData oglSrc = (OGLSurfaceData)srcData;
	308	OGLSurfaceData oglDst = (OGLSurfaceData)dstData;
	309	int srctype = oglSrc.getType();
	310	boolean rtt;
	311	OGLSurfaceData srcCtxData;
	312	if (srctype == OGLSurfaceData.TEXTURE) {
	313	// the source is a regular texture object; we substitute
	314	// the destination surface for the purposes of making a
	315	// context current
	316	rtt = false;
	317	srcCtxData = oglDst;
	318	} else {
	319	// the source is a pbuffer, backbuffer, or render-to-texture
	320	// surface; we set rtt to true to differentiate this kind
	321	// of surface from a regular texture object
	322	rtt = true;
	323	if (srctype == OGLSurfaceData.FBOBJECT) {
	324	srcCtxData = oglDst;
	325	} else {
	326	srcCtxData = oglSrc;
	327	}
	328	}
	329
	330	OGLContext.validateContext(srcCtxData, oglDst,
	331	clip, comp, xform, null, null,
	332	ctxflags);
	333
	334	if (biop != null) {
	335	OGLBufImgOps.enableBufImgOp(rq, oglSrc, srcImg, biop);
	336	}
	337
	338	int packedParams = createPackedParams(true, texture,
	339	rtt, xform != null,
	340	hint, 0 /unused/);
	341	enqueueBlit(rq, srcData, dstData,
	342	packedParams,
	343	sx1, sy1, sx2, sy2,
	344	dx1, dy1, dx2, dy2);
	345
	346	if (biop != null) {
	347	OGLBufImgOps.disableBufImgOp(rq, biop);
	348	}
	349
	350	if (rtt && (oglDst.getType() == OGLSurfaceData.WINDOW)) {
	351	// we only have to flush immediately when copying from a
	352	// (non-texture) surface to the screen; otherwise Swing apps
	353	// might appear unresponsive until the auto-flush completes
	354	rq.flushNow();
	355	}
	356	} finally {
	357	rq.unlock();
	358	}
	359	}
	360	}
	361
	362	class OGLSurfaceToSurfaceBlit extends Blit {
	363
	364	OGLSurfaceToSurfaceBlit() {
	365	super(OGLSurfaceData.OpenGLSurface,
	366	CompositeType.AnyAlpha,
	367	OGLSurfaceData.OpenGLSurface);
	368	}
	369
	370	public void Blit(SurfaceData src, SurfaceData dst,
	371	Composite comp, Region clip,
	372	int sx, int sy, int dx, int dy, int w, int h)
	373	{
	374	OGLBlitLoops.IsoBlit(src, dst,
	375	null, null,
	376	comp, clip, null,
	377	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	378	sx, sy, sx+w, sy+h,
	379	dx, dy, dx+w, dy+h,
	380	false);
	381	}
	382	}
	383
	384	class OGLSurfaceToSurfaceScale extends ScaledBlit {
	385
	386	OGLSurfaceToSurfaceScale() {
	387	super(OGLSurfaceData.OpenGLSurface,
	388	CompositeType.AnyAlpha,
	389	OGLSurfaceData.OpenGLSurface);
	390	}
	391
	392	public void Scale(SurfaceData src, SurfaceData dst,
	393	Composite comp, Region clip,
	394	int sx1, int sy1,
	395	int sx2, int sy2,
	396	double dx1, double dy1,
	397	double dx2, double dy2)
	398	{
	399	OGLBlitLoops.IsoBlit(src, dst,
	400	null, null,
	401	comp, clip, null,
	402	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	403	sx1, sy1, sx2, sy2,
	404	dx1, dy1, dx2, dy2,
	405	false);
	406	}
	407	}
	408
	409	class OGLSurfaceToSurfaceTransform extends TransformBlit {
	410
	411	OGLSurfaceToSurfaceTransform() {
	412	super(OGLSurfaceData.OpenGLSurface,
	413	CompositeType.AnyAlpha,
	414	OGLSurfaceData.OpenGLSurface);
	415	}
	416
	417	public void Transform(SurfaceData src, SurfaceData dst,
	418	Composite comp, Region clip,
	419	AffineTransform at, int hint,
	420	int sx, int sy, int dx, int dy,
	421	int w, int h)
	422	{
	423	OGLBlitLoops.IsoBlit(src, dst,
	424	null, null,
	425	comp, clip, at, hint,
	426	sx, sy, sx+w, sy+h,
	427	dx, dy, dx+w, dy+h,
	428	false);
	429	}
	430	}
	431
	432	class OGLRTTSurfaceToSurfaceBlit extends Blit {
	433
	434	OGLRTTSurfaceToSurfaceBlit() {
	435	super(OGLSurfaceData.OpenGLSurfaceRTT,
	436	CompositeType.AnyAlpha,
	437	OGLSurfaceData.OpenGLSurface);
	438	}
	439
	440	public void Blit(SurfaceData src, SurfaceData dst,
	441	Composite comp, Region clip,
	442	int sx, int sy, int dx, int dy, int w, int h)
	443	{
	444	OGLBlitLoops.IsoBlit(src, dst,
	445	null, null,
	446	comp, clip, null,
	447	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	448	sx, sy, sx+w, sy+h,
	449	dx, dy, dx+w, dy+h,
	450	true);
	451	}
	452	}
	453
	454	class OGLRTTSurfaceToSurfaceScale extends ScaledBlit {
	455
	456	OGLRTTSurfaceToSurfaceScale() {
	457	super(OGLSurfaceData.OpenGLSurfaceRTT,
	458	CompositeType.AnyAlpha,
	459	OGLSurfaceData.OpenGLSurface);
	460	}
	461
	462	public void Scale(SurfaceData src, SurfaceData dst,
	463	Composite comp, Region clip,
	464	int sx1, int sy1,
	465	int sx2, int sy2,
	466	double dx1, double dy1,
	467	double dx2, double dy2)
	468	{
	469	OGLBlitLoops.IsoBlit(src, dst,
	470	null, null,
	471	comp, clip, null,
	472	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	473	sx1, sy1, sx2, sy2,
	474	dx1, dy1, dx2, dy2,
	475	true);
	476	}
	477	}
	478
	479	class OGLRTTSurfaceToSurfaceTransform extends TransformBlit {
	480
	481	OGLRTTSurfaceToSurfaceTransform() {
	482	super(OGLSurfaceData.OpenGLSurfaceRTT,
	483	CompositeType.AnyAlpha,
	484	OGLSurfaceData.OpenGLSurface);
	485	}
	486
	487	public void Transform(SurfaceData src, SurfaceData dst,
	488	Composite comp, Region clip,
	489	AffineTransform at, int hint,
	490	int sx, int sy, int dx, int dy, int w, int h)
	491	{
	492	OGLBlitLoops.IsoBlit(src, dst,
	493	null, null,
	494	comp, clip, at, hint,
	495	sx, sy, sx+w, sy+h,
	496	dx, dy, dx+w, dy+h,
	497	true);
	498	}
	499	}
	500
	501	class OGLSurfaceToSwBlit extends Blit {
	502
	503	private int typeval;
	504
	505	// REMIND: destination will actually be opaque/premultiplied...
	506	OGLSurfaceToSwBlit(SurfaceType dstType, int typeval) {
	507	super(OGLSurfaceData.OpenGLSurface,
	508	CompositeType.SrcNoEa,
	509	dstType);
	510	this.typeval = typeval;
	511	}
	512
	513	public void Blit(SurfaceData src, SurfaceData dst,
	514	Composite comp, Region clip,
	515	int sx, int sy, int dx, int dy,
	516	int w, int h)
	517	{
	518	OGLRenderQueue rq = OGLRenderQueue.getInstance();
	519	rq.lock();
	520	try {
	521	// make sure the RenderQueue keeps a hard reference to the
	522	// destination (sysmem) SurfaceData to prevent it from being
	523	// disposed while the operation is processed on the QFT
	524	rq.addReference(dst);
	525
	526	RenderBuffer buf = rq.getBuffer();
	527	OGLContext.validateContext((OGLSurfaceData)src);
	528
	529	rq.ensureCapacityAndAlignment(48, 32);
	530	buf.putInt(SURFACE_TO_SW_BLIT);
	531	buf.putInt(sx).putInt(sy);
	532	buf.putInt(dx).putInt(dy);
	533	buf.putInt(w).putInt(h);
	534	buf.putInt(typeval);
	535	buf.putLong(src.getNativeOps());
	536	buf.putLong(dst.getNativeOps());
	537
	538	// always flush immediately
	539	rq.flushNow();
	540	} finally {
	541	rq.unlock();
	542	}
	543	}
	544	}
	545
	546	class OGLSwToSurfaceBlit extends Blit {
	547
	548	private int typeval;
	549
	550	OGLSwToSurfaceBlit(SurfaceType srcType, int typeval) {
	551	super(srcType,
	552	CompositeType.AnyAlpha,
	553	OGLSurfaceData.OpenGLSurface);
	554	this.typeval = typeval;
	555	}
	556
	557	public void Blit(SurfaceData src, SurfaceData dst,
	558	Composite comp, Region clip,
	559	int sx, int sy, int dx, int dy, int w, int h)
	560	{
	561	OGLBlitLoops.Blit(src, dst,
	562	comp, clip, null,
	563	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	564	sx, sy, sx+w, sy+h,
	565	dx, dy, dx+w, dy+h,
	566	typeval, false);
	567	}
	568	}
	569
	570	class OGLSwToSurfaceScale extends ScaledBlit {
	571
	572	private int typeval;
	573
	574	OGLSwToSurfaceScale(SurfaceType srcType, int typeval) {
	575	super(srcType,
	576	CompositeType.AnyAlpha,
	577	OGLSurfaceData.OpenGLSurface);
	578	this.typeval = typeval;
	579	}
	580
	581	public void Scale(SurfaceData src, SurfaceData dst,
	582	Composite comp, Region clip,
	583	int sx1, int sy1,
	584	int sx2, int sy2,
	585	double dx1, double dy1,
	586	double dx2, double dy2)
	587	{
	588	OGLBlitLoops.Blit(src, dst,
	589	comp, clip, null,
	590	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	591	sx1, sy1, sx2, sy2,
	592	dx1, dy1, dx2, dy2,
	593	typeval, false);
	594	}
	595	}
	596
	597	class OGLSwToSurfaceTransform extends TransformBlit {
	598
	599	private int typeval;
	600
	601	OGLSwToSurfaceTransform(SurfaceType srcType, int typeval) {
	602	super(srcType,
	603	CompositeType.AnyAlpha,
	604	OGLSurfaceData.OpenGLSurface);
	605	this.typeval = typeval;
	606	}
	607
	608	public void Transform(SurfaceData src, SurfaceData dst,
	609	Composite comp, Region clip,
	610	AffineTransform at, int hint,
	611	int sx, int sy, int dx, int dy, int w, int h)
	612	{
	613	OGLBlitLoops.Blit(src, dst,
	614	comp, clip, at, hint,
	615	sx, sy, sx+w, sy+h,
	616	dx, dy, dx+w, dy+h,
	617	typeval, false);
	618	}
	619	}
	620
	621	class OGLSwToTextureBlit extends Blit {
	622
	623	private int typeval;
	624
	625	OGLSwToTextureBlit(SurfaceType srcType, int typeval) {
	626	super(srcType,
	627	CompositeType.SrcNoEa,
	628	OGLSurfaceData.OpenGLTexture);
	629	this.typeval = typeval;
	630	}
	631
	632	public void Blit(SurfaceData src, SurfaceData dst,
	633	Composite comp, Region clip,
	634	int sx, int sy, int dx, int dy, int w, int h)
	635	{
	636	OGLBlitLoops.Blit(src, dst,
	637	comp, clip, null,
	638	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	639	sx, sy, sx+w, sy+h,
	640	dx, dy, dx+w, dy+h,
	641	typeval, true);
	642	}
	643	}
	644
	645	class OGLTextureToSurfaceBlit extends Blit {
	646
	647	OGLTextureToSurfaceBlit() {
	648	super(OGLSurfaceData.OpenGLTexture,
	649	CompositeType.AnyAlpha,
	650	OGLSurfaceData.OpenGLSurface);
	651	}
	652
	653	public void Blit(SurfaceData src, SurfaceData dst,
	654	Composite comp, Region clip,
	655	int sx, int sy, int dx, int dy, int w, int h)
	656	{
	657	OGLBlitLoops.IsoBlit(src, dst,
	658	null, null,
	659	comp, clip, null,
	660	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	661	sx, sy, sx+w, sy+h,
	662	dx, dy, dx+w, dy+h,
	663	true);
	664	}
	665	}
	666
	667	class OGLTextureToSurfaceScale extends ScaledBlit {
	668
	669	OGLTextureToSurfaceScale() {
	670	super(OGLSurfaceData.OpenGLTexture,
	671	CompositeType.AnyAlpha,
	672	OGLSurfaceData.OpenGLSurface);
	673	}
	674
	675	public void Scale(SurfaceData src, SurfaceData dst,
	676	Composite comp, Region clip,
	677	int sx1, int sy1,
	678	int sx2, int sy2,
	679	double dx1, double dy1,
	680	double dx2, double dy2)
	681	{
	682	OGLBlitLoops.IsoBlit(src, dst,
	683	null, null,
	684	comp, clip, null,
	685	AffineTransformOp.TYPE_NEAREST_NEIGHBOR,
	686	sx1, sy1, sx2, sy2,
	687	dx1, dy1, dx2, dy2,
	688	true);
	689	}
	690	}
	691
	692	class OGLTextureToSurfaceTransform extends TransformBlit {
	693
	694	OGLTextureToSurfaceTransform() {
	695	super(OGLSurfaceData.OpenGLTexture,
	696	CompositeType.AnyAlpha,
	697	OGLSurfaceData.OpenGLSurface);
	698	}
	699
	700	public void Transform(SurfaceData src, SurfaceData dst,
	701	Composite comp, Region clip,
	702	AffineTransform at, int hint,
	703	int sx, int sy, int dx, int dy,
	704	int w, int h)
	705	{
	706	OGLBlitLoops.IsoBlit(src, dst,
	707	null, null,
	708	comp, clip, at, hint,
	709	sx, sy, sx+w, sy+h,
	710	dx, dy, dx+w, dy+h,
	711	true);
	712	}
	713	}
	714
	715	/**
	716	* This general Blit implemenation converts any source surface to an
	717	* intermediate IntArgbPre surface, and then uses the more specific
	718	* IntArgbPre->OpenGLSurface/Texture loop to get the intermediate
	719	* (premultiplied) surface down to OpenGL.
	720	*/
	721	class OGLGeneralBlit extends Blit {
	722
	723	private Blit performop;
	724	private WeakReference srcTmp;
	725
	726	OGLGeneralBlit(SurfaceType dstType,
	727	CompositeType compType,
	728	Blit performop)
	729	{
	730	super(SurfaceType.Any, compType, dstType);
	731	this.performop = performop;
	732	}
	733
	734	public synchronized void Blit(SurfaceData src, SurfaceData dst,
	735	Composite comp, Region clip,
	736	int sx, int sy, int dx, int dy,
	737	int w, int h)
	738	{
	739	Blit convertsrc = Blit.getFromCache(src.getSurfaceType(),
	740	CompositeType.SrcNoEa,
	741	SurfaceType.IntArgbPre);
	742
	743	SurfaceData cachedSrc = null;
	744	if (srcTmp != null) {
	745	// use cached intermediate surface, if available
	746	cachedSrc = (SurfaceData)srcTmp.get();
	747	}
	748
	749	// convert source to IntArgbPre
	750	src = convertFrom(convertsrc, src, sx, sy, w, h,
	751	cachedSrc, BufferedImage.TYPE_INT_ARGB_PRE);
	752
	753	// copy IntArgbPre intermediate surface to OpenGL surface
	754	performop.Blit(src, dst, comp, clip,
	755	0, 0, dx, dy, w, h);
	756
	757	if (src != cachedSrc) {
	758	// cache the intermediate surface
	759	srcTmp = new WeakReference(src);
	760	}
	761	}
	762	}

java/pkg/sun/java2d/opengl/OGLBufImgOps.java+115−0

@@ -0,0 +1,115 @@
	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.opengl;
	27
	28	import java.awt.image.AffineTransformOp;
	29	import java.awt.image.BufferedImage;
	30	import java.awt.image.BufferedImageOp;
	31	import java.awt.image.ConvolveOp;
	32	import java.awt.image.LookupOp;
	33	import java.awt.image.RescaleOp;
	34	import sun.java2d.SunGraphics2D;
	35	import sun.java2d.SurfaceData;
	36	import sun.java2d.loops.CompositeType;
	37	import sun.java2d.pipe.BufferedBufImgOps;
	38	import static sun.java2d.opengl.OGLContext.OGLContextCaps.*;
	39
	40	class OGLBufImgOps extends BufferedBufImgOps {
	41
	42	/**
	43	* This method is called from OGLDrawImage.transformImage() only. It
	44	* validates the provided BufferedImageOp to determine whether the op
	45	* is one that can be accelerated by the OGL pipeline. If the operation
	46	* cannot be completed for any reason, this method returns false;
	47	* otherwise, the given BufferedImage is rendered to the destination
	48	* using the provided BufferedImageOp and this method returns true.
	49	*/
	50	static boolean renderImageWithOp(SunGraphics2D sg, BufferedImage img,
	51	BufferedImageOp biop, int x, int y)
	52	{
	53	// Validate the provided BufferedImage (make sure it is one that
	54	// is supported, and that its properties are acceleratable)
	55	if (biop instanceof ConvolveOp) {
	56	if (!isConvolveOpValid((ConvolveOp)biop)) {
	57	return false;
	58	}
	59	} else if (biop instanceof RescaleOp) {
	60	if (!isRescaleOpValid((RescaleOp)biop, img)) {
	61	return false;
	62	}
	63	} else if (biop instanceof LookupOp) {
	64	if (!isLookupOpValid((LookupOp)biop, img)) {
	65	return false;
	66	}
	67	} else {
	68	// No acceleration for other BufferedImageOps (yet)
	69	return false;
	70	}
	71
	72	SurfaceData dstData = sg.surfaceData;
	73	if (!(dstData instanceof OGLSurfaceData) \|\|
	74	(sg.interpolationType == AffineTransformOp.TYPE_BICUBIC) \|\|
	75	(sg.compositeState > SunGraphics2D.COMP_ALPHA))
	76	{
	77	return false;
	78	}
	79
	80	SurfaceData srcData =
	81	dstData.getSourceSurfaceData(img, sg.TRANSFORM_ISIDENT,
	82	CompositeType.SrcOver, null);
	83	if (!(srcData instanceof OGLSurfaceData)) {
	84	// REMIND: this hack tries to ensure that we have a cached texture
	85	srcData =
	86	dstData.getSourceSurfaceData(img, sg.TRANSFORM_ISIDENT,
	87	CompositeType.SrcOver, null);
	88	if (!(srcData instanceof OGLSurfaceData)) {
	89	return false;
	90	}
	91	}
	92
	93	// Verify that the source surface is actually a texture and
	94	// that the operation is supported
	95	OGLSurfaceData oglSrc = (OGLSurfaceData)srcData;
	96	OGLGraphicsConfig gc = oglSrc.getOGLGraphicsConfig();
	97	if (oglSrc.getType() != OGLSurfaceData.TEXTURE \|\|
	98	!gc.isCapPresent(CAPS_EXT_BIOP_SHADER))
	99	{
	100	return false;
	101	}
	102
	103	int sw = img.getWidth();
	104	int sh = img.getHeight();
	105	OGLBlitLoops.IsoBlit(srcData, dstData,
	106	img, biop,
	107	sg.composite, sg.getCompClip(),
	108	sg.transform, sg.interpolationType,
	109	0, 0, sw, sh,
	110	x, y, x+sw, y+sh,
	111	true);
	112
	113	return true;
	114	}
	115	}

java/pkg/sun/java2d/opengl/OGLContext.java+220−0

@@ -0,0 +1,220 @@
	1	/*
	2	* Copyright (c) 2004, 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.opengl;
	27
	28	import sun.java2d.pipe.BufferedContext;
	29	import sun.java2d.pipe.RenderBuffer;
	30	import sun.java2d.pipe.RenderQueue;
	31	import sun.java2d.pipe.hw.ContextCapabilities;
	32	import static sun.java2d.pipe.BufferedOpCodes.*;
	33	import static sun.java2d.pipe.hw.ContextCapabilities.*;
	34
	35	/**
	36	* Note that the RenderQueue lock must be acquired before calling any of
	37	* the methods in this class.
	38	*/
	39	public class OGLContext extends BufferedContext {
	40
	41	private final OGLGraphicsConfig config;
	42
	43	OGLContext(RenderQueue rq, OGLGraphicsConfig config) {
	44	super(rq);
	45	this.config = config;
	46	}
	47
	48	/**
	49	* Convenience method that delegates to setScratchSurface() below.
	50	*/
	51	static void setScratchSurface(OGLGraphicsConfig gc) {
	52	setScratchSurface(gc.getNativeConfigInfo());
	53	}
	54
	55	/**
	56	* Makes the given GraphicsConfig's context current to its associated
	57	* "scratch surface". Each GraphicsConfig maintains a native context
	58	* (GLXContext on Unix, HGLRC on Windows) as well as a native pbuffer
	59	* known as the "scratch surface". By making the context current to the
	60	* scratch surface, we are assured that we have a current context for
	61	* the relevant GraphicsConfig, and can therefore perform operations
	62	* depending on the capabilities of that GraphicsConfig. For example,
	63	* if the GraphicsConfig supports the GL_ARB_texture_non_power_of_two
	64	* extension, then we should be able to make a non-pow2 texture for this
	65	* GraphicsConfig once we make the context current to the scratch surface.
	66	*
	67	* This method should be used for operations with an OpenGL texture
	68	* as the destination surface (e.g. a sw->texture blit loop), or in those
	69	* situations where we may not otherwise have a current context (e.g.
	70	* when disposing a texture-based surface).
	71	*/
	72	static void setScratchSurface(long pConfigInfo) {
	73	// assert OGLRenderQueue.getInstance().lock.isHeldByCurrentThread();
	74
	75	// invalidate the current context
	76	currentContext = null;
	77
	78	// set the scratch context
	79	OGLRenderQueue rq = OGLRenderQueue.getInstance();
	80	RenderBuffer buf = rq.getBuffer();
	81	rq.ensureCapacityAndAlignment(12, 4);
	82	buf.putInt(SET_SCRATCH_SURFACE);
	83	buf.putLong(pConfigInfo);
	84	}
	85
	86	/**
	87	* Invalidates the currentContext field to ensure that we properly
	88	* revalidate the OGLContext (make it current, etc.) next time through
	89	* the validate() method. This is typically invoked from methods
	90	* that affect the current context state (e.g. disposing a context or
	91	* surface).
	92	*/
	93	static void invalidateCurrentContext() {
	94	// assert OGLRenderQueue.getInstance().lock.isHeldByCurrentThread();
	95
	96	// invalidate the current Java-level context so that we
	97	// revalidate everything the next time around
	98	if (currentContext != null) {
	99	currentContext.invalidateContext();
	100	currentContext = null;
	101	}
	102
	103	// invalidate the context reference at the native level, and
	104	// then flush the queue so that we have no pending operations
	105	// dependent on the current context
	106	OGLRenderQueue rq = OGLRenderQueue.getInstance();
	107	rq.ensureCapacity(4);
	108	rq.getBuffer().putInt(INVALIDATE_CONTEXT);
	109	rq.flushNow();
	110	}
	111
	112	public RenderQueue getRenderQueue() {
	113	return OGLRenderQueue.getInstance();
	114	}
	115
	116	/**
	117	* Returns a string representing adapter id (vendor, renderer, version).
	118	* Must be called on the rendering thread.
	119	*
	120	* @return an id string for the adapter
	121	*/
	122	static final native String getOGLIdString();
	123
	124	@Override
	125	public void saveState() {
	126	// assert rq.lock.isHeldByCurrentThread();
	127
	128	// reset all attributes of this and current contexts
	129	invalidateContext();
	130	invalidateCurrentContext();
	131
	132	setScratchSurface(config);
	133
	134	// save the state on the native level
	135	rq.ensureCapacity(4);
	136	buf.putInt(SAVE_STATE);
	137	rq.flushNow();
	138	}
	139
	140	@Override
	141	public void restoreState() {
	142	// assert rq.lock.isHeldByCurrentThread();
	143
	144	// reset all attributes of this and current contexts
	145	invalidateContext();
	146	invalidateCurrentContext();
	147
	148	setScratchSurface(config);
	149
	150	// restore the state on the native level
	151	rq.ensureCapacity(4);
	152	buf.putInt(RESTORE_STATE);
	153	rq.flushNow();
	154	}
	155
	156	static class OGLContextCaps extends ContextCapabilities {
	157	/**
	158	* Indicates the presence of the GL_EXT_framebuffer_object extension.
	159	* This cap will only be set if the fbobject system property has been
	160	* enabled and we are able to create an FBO with depth buffer.
	161	*/
	162	static final int CAPS_EXT_FBOBJECT =
	163	(CAPS_RT_TEXTURE_ALPHA \| CAPS_RT_TEXTURE_OPAQUE);
	164	/** Indicates that the context supports a stored alpha channel. */
	165	static final int CAPS_STORED_ALPHA = CAPS_RT_PLAIN_ALPHA;
	166	/** Indicates that the context is doublebuffered. */
	167	static final int CAPS_DOUBLEBUFFERED = (FIRST_PRIVATE_CAP << 0);
	168	/**
	169	* Indicates the presence of the GL_ARB_fragment_shader extension.
	170	* This cap will only be set if the lcdshader system property has been
	171	* enabled and the hardware supports the minimum number of texture units
	172	*/
	173	static final int CAPS_EXT_LCD_SHADER = (FIRST_PRIVATE_CAP << 1);
	174	/**
	175	* Indicates the presence of the GL_ARB_fragment_shader extension.
	176	* This cap will only be set if the biopshader system property has been
	177	* enabled and the hardware meets our minimum requirements.
	178	*/
	179	static final int CAPS_EXT_BIOP_SHADER = (FIRST_PRIVATE_CAP << 2);
	180	/**
	181	* Indicates the presence of the GL_ARB_fragment_shader extension.
	182	* This cap will only be set if the gradshader system property has been
	183	* enabled and the hardware meets our minimum requirements.
	184	*/
	185	static final int CAPS_EXT_GRAD_SHADER = (FIRST_PRIVATE_CAP << 3);
	186	/** Indicates the presence of the GL_ARB_texture_rectangle extension. */
	187	static final int CAPS_EXT_TEXRECT = (FIRST_PRIVATE_CAP << 4);
	188
	189	OGLContextCaps(int caps, String adapterId) {
	190	super(caps, adapterId);
	191	}
	192
	193	@Override
	194	public String toString() {
	195	StringBuffer buf = new StringBuffer(super.toString());
	196	if ((caps & CAPS_EXT_FBOBJECT) != 0) {
	197	buf.append("CAPS_EXT_FBOBJECT\|");
	198	}
	199	if ((caps & CAPS_STORED_ALPHA) != 0) {
	200	buf.append("CAPS_STORED_ALPHA\|");
	201	}
	202	if ((caps & CAPS_DOUBLEBUFFERED) != 0) {
	203	buf.append("CAPS_DOUBLEBUFFERED\|");
	204	}
	205	if ((caps & CAPS_EXT_LCD_SHADER) != 0) {
	206	buf.append("CAPS_EXT_LCD_SHADER\|");
	207	}
	208	if ((caps & CAPS_EXT_BIOP_SHADER) != 0) {
	209	buf.append("CAPS_BIOP_SHADER\|");
	210	}
	211	if ((caps & CAPS_EXT_GRAD_SHADER) != 0) {
	212	buf.append("CAPS_EXT_GRAD_SHADER\|");
	213	}
	214	if ((caps & CAPS_EXT_TEXRECT) != 0) {
	215	buf.append("CAPS_EXT_TEXRECT\|");
	216	}
	217	return buf.toString();
	218	}
	219	}
	220	}

java/pkg/sun/java2d/opengl/OGLDrawImage.java+113−0

@@ -0,0 +1,113 @@
	1	/*
	2	* Copyright (c) 2003, 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.opengl;
	27
	28	import java.awt.Color;
	29	import java.awt.Image;
	30	import java.awt.geom.AffineTransform;
	31	import java.awt.image.AffineTransformOp;
	32	import java.awt.image.BufferedImage;
	33	import java.awt.image.BufferedImageOp;
	34	import sun.java2d.SunGraphics2D;
	35	import sun.java2d.SurfaceData;
	36	import sun.java2d.loops.SurfaceType;
	37	import sun.java2d.loops.TransformBlit;
	38	import sun.java2d.pipe.DrawImage;
	39
	40	public class OGLDrawImage extends DrawImage {
	41
	42	@Override
	43	protected void renderImageXform(SunGraphics2D sg, Image img,
	44	AffineTransform tx, int interpType,
	45	int sx1, int sy1, int sx2, int sy2,
	46	Color bgColor)
	47	{
	48	// punt to the MediaLib-based transformImage() in the superclass if:
	49	// - bicubic interpolation is specified
	50	// - a background color is specified and will be used
	51	// - the source surface is neither a texture nor render-to-texture
	52	// surface, and a non-default interpolation hint is specified
	53	// (we can only control the filtering for texture->surface
	54	// copies)
	55	// REMIND: we should tweak the sw->texture->surface
	56	// transform case to handle filtering appropriately
	57	// (see 4841762)...
	58	// - an appropriate TransformBlit primitive could not be found
	59	if (interpType != AffineTransformOp.TYPE_BICUBIC) {
	60	SurfaceData dstData = sg.surfaceData;
	61	SurfaceData srcData =
	62	dstData.getSourceSurfaceData(img,
	63	sg.TRANSFORM_GENERIC,
	64	sg.imageComp,
	65	bgColor);
	66
	67	if (srcData != null &&
	68	!isBgOperation(srcData, bgColor) &&
	69	(srcData.getSurfaceType() == OGLSurfaceData.OpenGLTexture \|\|
	70	srcData.getSurfaceType() == OGLSurfaceData.OpenGLSurfaceRTT \|\|
	71	interpType == AffineTransformOp.TYPE_NEAREST_NEIGHBOR))
	72	{
	73	SurfaceType srcType = srcData.getSurfaceType();
	74	SurfaceType dstType = dstData.getSurfaceType();
	75	TransformBlit blit = TransformBlit.getFromCache(srcType,
	76	sg.imageComp,
	77	dstType);
	78
	79	if (blit != null) {
	80	blit.Transform(srcData, dstData,
	81	sg.composite, sg.getCompClip(),
	82	tx, interpType,
	83	sx1, sy1, 0, 0, sx2-sx1, sy2-sy1);
	84	return;
	85	}
	86	}
	87	}
	88
	89	super.renderImageXform(sg, img, tx, interpType,
	90	sx1, sy1, sx2, sy2, bgColor);
	91	}
	92
	93	@Override
	94	public void transformImage(SunGraphics2D sg, BufferedImage img,
	95	BufferedImageOp op, int x, int y)
	96	{
	97	if (op != null) {
	98	if (op instanceof AffineTransformOp) {
	99	AffineTransformOp atop = (AffineTransformOp) op;
	100	transformImage(sg, img, x, y,
	101	atop.getTransform(),
	102	atop.getInterpolationType());
	103	return;
	104	} else {
	105	if (OGLBufImgOps.renderImageWithOp(sg, img, op, x, y)) {
	106	return;
	107	}
	108	}
	109	img = op.filter(img, null);
	110	}
	111	copyImage(sg, img, x, y, null);
	112	}
	113	}

java/pkg/sun/java2d/opengl/OGLGraphicsConfig.java+44−0

@@ -0,0 +1,44 @@
	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.opengl;
	27
	28	import sun.java2d.SurfaceData;
	29	import sun.awt.image.SurfaceManager;
	30	import sun.java2d.pipe.hw.AccelGraphicsConfig;
	31
	32	/**
	33	* This interface collects the methods that are provided by both
	34	* GLXGraphicsConfig and WGLGraphicsConfig, making it easier to invoke these
	35	* methods directly from OGLSurfaceData.
	36	*/
	37	interface OGLGraphicsConfig extends
	38	AccelGraphicsConfig, SurfaceManager.ProxiedGraphicsConfig
	39	{
	40	OGLContext getContext();
	41	long getNativeConfigInfo();
	42	boolean isCapPresent(int cap);
	43	SurfaceData createManagedSurface(int w, int h, int transparency);
	44	}

java/pkg/sun/java2d/opengl/OGLMaskBlit.java+69−0

@@ -0,0 +1,69 @@
	1	/*
	2	* Copyright (c) 2003, 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.opengl;
	27
	28	import java.awt.Composite;
	29	import sun.java2d.SurfaceData;
	30	import sun.java2d.loops.CompositeType;
	31	import sun.java2d.loops.GraphicsPrimitive;
	32	import sun.java2d.loops.GraphicsPrimitiveMgr;
	33	import sun.java2d.loops.SurfaceType;
	34	import sun.java2d.pipe.Region;
	35	import sun.java2d.pipe.BufferedMaskBlit;
	36	import static sun.java2d.loops.CompositeType.*;
	37	import static sun.java2d.loops.SurfaceType.*;
	38
	39	class OGLMaskBlit extends BufferedMaskBlit {
	40
	41	static void register() {
	42	GraphicsPrimitive[] primitives = {
	43	new OGLMaskBlit(IntArgb, SrcOver),
	44	new OGLMaskBlit(IntArgbPre, SrcOver),
	45	new OGLMaskBlit(IntRgb, SrcOver),
	46	new OGLMaskBlit(IntRgb, SrcNoEa),
	47	new OGLMaskBlit(IntBgr, SrcOver),
	48	new OGLMaskBlit(IntBgr, SrcNoEa),
	49	};
	50	GraphicsPrimitiveMgr.register(primitives);
	51	}
	52
	53	private OGLMaskBlit(SurfaceType srcType,
	54	CompositeType compType)
	55	{
	56	super(OGLRenderQueue.getInstance(),
	57	srcType, compType, OGLSurfaceData.OpenGLSurface);
	58	}
	59
	60	@Override
	61	protected void validateContext(SurfaceData dstData,
	62	Composite comp, Region clip)
	63	{
	64	OGLSurfaceData oglDst = (OGLSurfaceData)dstData;
	65	OGLContext.validateContext(oglDst, oglDst,
	66	clip, comp, null, null, null,
	67	OGLContext.NO_CONTEXT_FLAGS);
	68	}
	69	}

java/pkg/sun/java2d/opengl/OGLMaskFill.java+75−0

@@ -0,0 +1,75 @@
	1	/*
	2	* Copyright (c) 2003, 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.opengl;
	27
	28	import java.awt.Composite;
	29	import sun.java2d.SunGraphics2D;
	30	import sun.java2d.loops.GraphicsPrimitive;
	31	import sun.java2d.loops.GraphicsPrimitiveMgr;
	32	import sun.java2d.loops.CompositeType;
	33	import sun.java2d.loops.SurfaceType;
	34	import sun.java2d.pipe.BufferedMaskFill;
	35	import static sun.java2d.loops.CompositeType.*;
	36	import static sun.java2d.loops.SurfaceType.*;
	37
	38	class OGLMaskFill extends BufferedMaskFill {
	39
	40	static void register() {
	41	GraphicsPrimitive[] primitives = {
	42	new OGLMaskFill(AnyColor, SrcOver),
	43	new OGLMaskFill(OpaqueColor, SrcNoEa),
	44	new OGLMaskFill(GradientPaint, SrcOver),
	45	new OGLMaskFill(OpaqueGradientPaint, SrcNoEa),
	46	new OGLMaskFill(LinearGradientPaint, SrcOver),
	47	new OGLMaskFill(OpaqueLinearGradientPaint, SrcNoEa),
	48	new OGLMaskFill(RadialGradientPaint, SrcOver),
	49	new OGLMaskFill(OpaqueRadialGradientPaint, SrcNoEa),
	50	new OGLMaskFill(TexturePaint, SrcOver),
	51	new OGLMaskFill(OpaqueTexturePaint, SrcNoEa),
	52	};
	53	GraphicsPrimitiveMgr.register(primitives);
	54	}
	55
	56	protected OGLMaskFill(SurfaceType srcType, CompositeType compType) {
	57	super(OGLRenderQueue.getInstance(),
	58	srcType, compType, OGLSurfaceData.OpenGLSurface);
	59	}
	60
	61	@Override
	62	protected native void maskFill(int x, int y, int w, int h,
	63	int maskoff, int maskscan, int masklen,
	64	byte[] mask);
	65
	66	@Override
	67	protected void validateContext(SunGraphics2D sg2d,
	68	Composite comp, int ctxflags)
	69	{
	70	OGLSurfaceData dstData = (OGLSurfaceData)sg2d.surfaceData;
	71	OGLContext.validateContext(dstData, dstData,
	72	sg2d.getCompClip(), comp,
	73	null, sg2d.paint, sg2d, ctxflags);
	74	}
	75	}

java/pkg/sun/java2d/opengl/OGLPaints.java+209−0

@@ -0,0 +1,209 @@
	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.opengl;
	27
	28	import java.awt.GradientPaint;
	29	import java.awt.LinearGradientPaint;
	30	import java.awt.MultipleGradientPaint;
	31	import java.awt.MultipleGradientPaint.ColorSpaceType;
	32	import java.awt.MultipleGradientPaint.CycleMethod;
	33	import java.awt.RadialGradientPaint;
	34	import java.awt.TexturePaint;
	35	import java.awt.image.BufferedImage;
	36	import java.util.HashMap;
	37	import java.util.Map;
	38	import sun.java2d.SunGraphics2D;
	39	import sun.java2d.SurfaceData;
	40	import sun.java2d.loops.CompositeType;
	41	import static sun.java2d.pipe.BufferedPaints.*;
	42	import static sun.java2d.opengl.OGLContext.OGLContextCaps.*;
	43
	44	abstract class OGLPaints {
	45
	46	/**
	47	* Holds all registered implementations, using the corresponding
	48	* SunGraphics2D.PAINT_* constant as the hash key.
	49	*/
	50	private static Map<Integer, OGLPaints> impls =
	51	new HashMap<Integer, OGLPaints>(4, 1.0f);
	52
	53	static {
	54	impls.put(SunGraphics2D.PAINT_GRADIENT, new Gradient());
	55	impls.put(SunGraphics2D.PAINT_LIN_GRADIENT, new LinearGradient());
	56	impls.put(SunGraphics2D.PAINT_RAD_GRADIENT, new RadialGradient());
	57	impls.put(SunGraphics2D.PAINT_TEXTURE, new Texture());
	58	}
	59
	60	/**
	61	* Attempts to locate an implementation corresponding to the paint state
	62	* of the provided SunGraphics2D object. If no implementation can be
	63	* found, or if the paint cannot be accelerated under the conditions
	64	* of the SunGraphics2D, this method returns false; otherwise, returns
	65	* true.
	66	*/
	67	static boolean isValid(SunGraphics2D sg2d) {
	68	OGLPaints impl = impls.get(sg2d.paintState);
	69	return (impl != null && impl.isPaintValid(sg2d));
	70	}
	71
	72	/**
	73	* Returns true if this implementation is able to accelerate the
	74	* Paint object associated with, and under the conditions of, the
	75	* provided SunGraphics2D instance; otherwise returns false.
	76	*/
	77	abstract boolean isPaintValid(SunGraphics2D sg2d);
	78
	79	/*********************** GradientPaint support **************************/
	80
	81	private static class Gradient extends OGLPaints {
	82	private Gradient() {}
	83
	84	/**
	85	* There are no restrictions for accelerating GradientPaint, so
	86	* this method always returns true.
	87	*/
	88	@Override
	89	boolean isPaintValid(SunGraphics2D sg2d) {
	90	return true;
	91	}
	92	}
	93
	94	/************************ TexturePaint support **************************/
	95
	96	private static class Texture extends OGLPaints {
	97	private Texture() {}
	98
	99	/**
	100	* Returns true if the given TexturePaint instance can be used by the
	101	* accelerated OGLPaints.Texture implementation. A TexturePaint is
	102	* considered valid if the following conditions are met:
	103	* - the texture image dimensions are power-of-two (or the
	104	* GL_ARB_texture_non_power_of_two extension is present)
	105	* - the texture image can be (or is already) cached in an OpenGL
	106	* texture object
	107	*/
	108	@Override
	109	boolean isPaintValid(SunGraphics2D sg2d) {
	110	TexturePaint paint = (TexturePaint)sg2d.paint;
	111	OGLSurfaceData dstData = (OGLSurfaceData)sg2d.surfaceData;
	112	BufferedImage bi = paint.getImage();
	113
	114	// see if texture-non-pow2 extension is available
	115	if (!dstData.isTexNonPow2Available()) {
	116	int imgw = bi.getWidth();
	117	int imgh = bi.getHeight();
	118
	119	// verify that the texture image dimensions are pow2
	120	if ((imgw & (imgw - 1)) != 0 \|\| (imgh & (imgh - 1)) != 0) {
	121	return false;
	122	}
	123	}
	124
	125	SurfaceData srcData =
	126	dstData.getSourceSurfaceData(bi, sg2d.TRANSFORM_ISIDENT,
	127	CompositeType.SrcOver, null);
	128	if (!(srcData instanceof OGLSurfaceData)) {
	129	// REMIND: this is a hack that attempts to cache the system
	130	// memory image from the TexturePaint instance into an
	131	// OpenGL texture...
	132	srcData =
	133	dstData.getSourceSurfaceData(bi, sg2d.TRANSFORM_ISIDENT,
	134	CompositeType.SrcOver, null);
	135	if (!(srcData instanceof OGLSurfaceData)) {
	136	return false;
	137	}
	138	}
	139
	140	// verify that the source surface is actually a texture
	141	OGLSurfaceData oglData = (OGLSurfaceData)srcData;
	142	if (oglData.getType() != OGLSurfaceData.TEXTURE) {
	143	return false;
	144	}
	145
	146	return true;
	147	}
	148	}
	149
	150	/**************** Shared MultipleGradientPaint support ******************/
	151
	152	private static abstract class MultiGradient extends OGLPaints {
	153	protected MultiGradient() {}
	154
	155	/**
	156	* Returns true if the given MultipleGradientPaint instance can be
	157	* used by the accelerated OGLPaints.MultiGradient implementation.
	158	* A MultipleGradientPaint is considered valid if the following
	159	* conditions are met:
	160	* - the number of gradient "stops" is <= MAX_FRACTIONS
	161	* - the destination has support for fragment shaders
	162	*/
	163	@Override
	164	boolean isPaintValid(SunGraphics2D sg2d) {
	165	MultipleGradientPaint paint = (MultipleGradientPaint)sg2d.paint;
	166	// REMIND: ugh, this creates garbage; would be nicer if
	167	// we had a MultipleGradientPaint.getNumStops() method...
	168	if (paint.getFractions().length > MULTI_MAX_FRACTIONS) {
	169	return false;
	170	}
	171
	172	OGLSurfaceData dstData = (OGLSurfaceData)sg2d.surfaceData;
	173	OGLGraphicsConfig gc = dstData.getOGLGraphicsConfig();
	174	if (!gc.isCapPresent(CAPS_EXT_GRAD_SHADER)) {
	175	return false;
	176	}
	177
	178	return true;
	179	}
	180	}
	181
	182	/******************** LinearGradientPaint support ***********************/
	183
	184	private static class LinearGradient extends MultiGradient {
	185	private LinearGradient() {}
	186
	187	@Override
	188	boolean isPaintValid(SunGraphics2D sg2d) {
	189	LinearGradientPaint paint = (LinearGradientPaint)sg2d.paint;
	190
	191	if (paint.getFractions().length == 2 &&
	192	paint.getCycleMethod() != CycleMethod.REPEAT &&
	193	paint.getColorSpace() != ColorSpaceType.LINEAR_RGB)
	194	{
	195	// we can delegate to the optimized two-color gradient
	196	// codepath, which does not require fragment shader support
	197	return true;
	198	}
	199
	200	return super.isPaintValid(sg2d);
	201	}
	202	}
	203
	204	/******************** RadialGradientPaint support ***********************/
	205
	206	private static class RadialGradient extends MultiGradient {
	207	private RadialGradient() {}
	208	}
	209	}

java/pkg/sun/java2d/opengl/OGLRenderQueue.java+239−0

@@ -0,0 +1,239 @@
	1	/*
	2	* Copyright (c) 2005, 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.opengl;
	27
	28	import sun.java2d.pipe.RenderBuffer;
	29	import sun.java2d.pipe.RenderQueue;
	30	import static sun.java2d.pipe.BufferedOpCodes.*;
	31
	32	/**
	33	* OGL-specific implementation of RenderQueue. This class provides a
	34	* single (daemon) thread that is responsible for periodically flushing
	35	* the queue, thus ensuring that only one thread communicates with the native
	36	* OpenGL libraries for the entire process.
	37	*/
	38	public class OGLRenderQueue extends RenderQueue {
	39
	40	private static OGLRenderQueue theInstance;
	41	private final QueueFlusher flusher;
	42
	43	private OGLRenderQueue() {
	44	flusher = new QueueFlusher();
	45	}
	46
	47	/**
	48	* Returns the single OGLRenderQueue instance. If it has not yet been
	49	* initialized, this method will first construct the single instance
	50	* before returning it.
	51	*/
	52	public static synchronized OGLRenderQueue getInstance() {
	53	if (theInstance == null) {
	54	theInstance = new OGLRenderQueue();
	55	}
	56	return theInstance;
	57	}
	58
	59	/**
	60	* Flushes the single OGLRenderQueue instance synchronously. If an
	61	* OGLRenderQueue has not yet been instantiated, this method is a no-op.
	62	* This method is useful in the case of Toolkit.sync(), in which we want
	63	* to flush the OGL pipeline, but only if the OGL pipeline is currently
	64	* enabled. Since this class has few external dependencies, callers need
	65	* not be concerned that calling this method will trigger initialization
	66	* of the OGL pipeline and related classes.
	67	*/
	68	public static void sync() {
	69	if (theInstance != null) {
	70	theInstance.lock();
	71	try {
	72	theInstance.ensureCapacity(4);
	73	theInstance.getBuffer().putInt(SYNC);
	74	theInstance.flushNow();
	75	} finally {
	76	theInstance.unlock();
	77	}
	78	}
	79	}
	80
	81	/**
	82	* Disposes the native memory associated with the given native
	83	* graphics config info pointer on the single queue flushing thread.
	84	*/
	85	public static void disposeGraphicsConfig(long pConfigInfo) {
	86	OGLRenderQueue rq = getInstance();
	87	rq.lock();
	88	try {
	89	// make sure we make the context associated with the given
	90	// GraphicsConfig current before disposing the native resources
	91	OGLContext.setScratchSurface(pConfigInfo);
	92
	93	RenderBuffer buf = rq.getBuffer();
	94	rq.ensureCapacityAndAlignment(12, 4);
	95	buf.putInt(DISPOSE_CONFIG);
	96	buf.putLong(pConfigInfo);
	97
	98	// this call is expected to complete synchronously, so flush now
	99	rq.flushNow();
	100	} finally {
	101	rq.unlock();
	102	}
	103	}
	104
	105	/**
	106	* Returns true if the current thread is the OGL QueueFlusher thread.
	107	*/
	108	public static boolean isQueueFlusherThread() {
	109	return (Thread.currentThread() == getInstance().flusher);
	110	}
	111
	112	public void flushNow() {
	113	// assert lock.isHeldByCurrentThread();
	114	try {
	115	flusher.flushNow();
	116	} catch (Exception e) {
	117	System.err.println("exception in flushNow:");
	118	e.printStackTrace();
	119	}
	120	}
	121
	122	public void flushAndInvokeNow(Runnable r) {
	123	// assert lock.isHeldByCurrentThread();
	124	try {
	125	flusher.flushAndInvokeNow(r);
	126	} catch (Exception e) {
	127	System.err.println("exception in flushAndInvokeNow:");
	128	e.printStackTrace();
	129	}
	130	}
	131
	132	private native void flushBuffer(long buf, int limit);
	133
	134	private void flushBuffer() {
	135	// assert lock.isHeldByCurrentThread();
	136	int limit = buf.position();
	137	if (limit > 0) {
	138	// process the queue
	139	flushBuffer(buf.getAddress(), limit);
	140	}
	141	// reset the buffer position
	142	buf.clear();
	143	// clear the set of references, since we no longer need them
	144	refSet.clear();
	145	}
	146
	147	private class QueueFlusher extends Thread {
	148	private boolean needsFlush;
	149	private Runnable task;
	150	private Error error;
	151
	152	public QueueFlusher() {
	153	super("Java2D Queue Flusher");
	154	setDaemon(true);
	155	setPriority(Thread.MAX_PRIORITY);
	156	start();
	157	}
	158
	159	public synchronized void flushNow() {
	160	// wake up the flusher
	161	needsFlush = true;
	162	notify();
	163
	164	// wait for flush to complete
	165	while (needsFlush) {
	166	try {
	167	wait();
	168	} catch (InterruptedException e) {
	169	}
	170	}
	171
	172	// re-throw any error that may have occurred during the flush
	173	if (error != null) {
	174	throw error;
	175	}
	176	}
	177
	178	public synchronized void flushAndInvokeNow(Runnable task) {
	179	this.task = task;
	180	flushNow();
	181	}
	182
	183	public synchronized void run() {
	184	boolean timedOut = false;
	185	while (true) {
	186	while (!needsFlush) {
	187	try {
	188	timedOut = false;
	189	/*
	190	* Wait until we're woken up with a flushNow() call,
	191	* or the timeout period elapses (so that we can
	192	* flush the queue periodically).
	193	*/
	194	wait(100);
	195	/*
	196	* We will automatically flush the queue if the
	197	* following conditions apply:
	198	* - the wait() timed out
	199	* - we can lock the queue (without blocking)
	200	* - there is something in the queue to flush
	201	* Otherwise, just continue (we'll flush eventually).
	202	*/
	203	if (!needsFlush && (timedOut = tryLock())) {
	204	if (buf.position() > 0) {
	205	needsFlush = true;
	206	} else {
	207	unlock();
	208	}
	209	}
	210	} catch (InterruptedException e) {
	211	}
	212	}
	213	try {
	214	// reset the throwable state
	215	error = null;
	216	// flush the buffer now
	217	flushBuffer();
	218	// if there's a task, invoke that now as well
	219	if (task != null) {
	220	task.run();
	221	}
	222	} catch (Error e) {
	223	error = e;
	224	} catch (Exception x) {
	225	System.err.println("exception in QueueFlusher:");
	226	x.printStackTrace();
	227	} finally {
	228	if (timedOut) {
	229	unlock();
	230	}
	231	task = null;
	232	// allow the waiting thread to continue
	233	needsFlush = false;
	234	notify();
	235	}
	236	}
	237	}
	238	}
	239	}

java/pkg/sun/java2d/opengl/OGLRenderer.java+206−0

@@ -0,0 +1,206 @@
	1	/*
	2	* Copyright (c) 2003, 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.opengl;
	27
	28	import java.awt.Transparency;
	29	import java.awt.geom.Path2D;
	30	import sun.java2d.SunGraphics2D;
	31	import sun.java2d.loops.GraphicsPrimitive;
	32	import sun.java2d.pipe.BufferedRenderPipe;
	33	import sun.java2d.pipe.ParallelogramPipe;
	34	import sun.java2d.pipe.RenderQueue;
	35	import sun.java2d.pipe.SpanIterator;
	36	import static sun.java2d.pipe.BufferedOpCodes.*;
	37
	38	class OGLRenderer extends BufferedRenderPipe {
	39
	40	OGLRenderer(RenderQueue rq) {
	41	super(rq);
	42	}
	43
	44	@Override
	45	protected void validateContext(SunGraphics2D sg2d) {
	46	int ctxflags =
	47	sg2d.paint.getTransparency() == Transparency.OPAQUE ?
	48	OGLContext.SRC_IS_OPAQUE : OGLContext.NO_CONTEXT_FLAGS;
	49	OGLSurfaceData dstData = (OGLSurfaceData)sg2d.surfaceData;
	50	OGLContext.validateContext(dstData, dstData,
	51	sg2d.getCompClip(), sg2d.composite,
	52	null, sg2d.paint, sg2d, ctxflags);
	53	}
	54
	55	@Override
	56	protected void validateContextAA(SunGraphics2D sg2d) {
	57	int ctxflags = OGLContext.NO_CONTEXT_FLAGS;
	58	OGLSurfaceData dstData = (OGLSurfaceData)sg2d.surfaceData;
	59	OGLContext.validateContext(dstData, dstData,
	60	sg2d.getCompClip(), sg2d.composite,
	61	null, sg2d.paint, sg2d, ctxflags);
	62	}
	63
	64	void copyArea(SunGraphics2D sg2d,
	65	int x, int y, int w, int h, int dx, int dy)
	66	{
	67	rq.lock();
	68	try {
	69	int ctxflags =
	70	sg2d.surfaceData.getTransparency() == Transparency.OPAQUE ?
	71	OGLContext.SRC_IS_OPAQUE : OGLContext.NO_CONTEXT_FLAGS;
	72	OGLSurfaceData dstData = (OGLSurfaceData)sg2d.surfaceData;
	73	OGLContext.validateContext(dstData, dstData,
	74	sg2d.getCompClip(), sg2d.composite,
	75	null, null, null, ctxflags);
	76
	77	rq.ensureCapacity(28);
	78	buf.putInt(COPY_AREA);
	79	buf.putInt(x).putInt(y).putInt(w).putInt(h);
	80	buf.putInt(dx).putInt(dy);
	81	} finally {
	82	rq.unlock();
	83	}
	84	}
	85
	86	@Override
	87	protected native void drawPoly(int[] xPoints, int[] yPoints,
	88	int nPoints, boolean isClosed,
	89	int transX, int transY);
	90
	91	OGLRenderer traceWrap() {
	92	return new Tracer(this);
	93	}
	94
	95	private class Tracer extends OGLRenderer {
	96	private OGLRenderer oglr;
	97	Tracer(OGLRenderer oglr) {
	98	super(oglr.rq);
	99	this.oglr = oglr;
	100	}
	101	public ParallelogramPipe getAAParallelogramPipe() {
	102	final ParallelogramPipe realpipe = oglr.getAAParallelogramPipe();
	103	return new ParallelogramPipe() {
	104	public void fillParallelogram(SunGraphics2D sg2d,
	105	double ux1, double uy1,
	106	double ux2, double uy2,
	107	double x, double y,
	108	double dx1, double dy1,
	109	double dx2, double dy2)
	110	{
	111	GraphicsPrimitive.tracePrimitive("OGLFillAAParallelogram");
	112	realpipe.fillParallelogram(sg2d,
	113	ux1, uy1, ux2, uy2,
	114	x, y, dx1, dy1, dx2, dy2);
	115	}
	116	public void drawParallelogram(SunGraphics2D sg2d,
	117	double ux1, double uy1,
	118	double ux2, double uy2,
	119	double x, double y,
	120	double dx1, double dy1,
	121	double dx2, double dy2,
	122	double lw1, double lw2)
	123	{
	124	GraphicsPrimitive.tracePrimitive("OGLDrawAAParallelogram");
	125	realpipe.drawParallelogram(sg2d,
	126	ux1, uy1, ux2, uy2,
	127	x, y, dx1, dy1, dx2, dy2,
	128	lw1, lw2);
	129	}
	130	};
	131	}
	132	protected void validateContext(SunGraphics2D sg2d) {
	133	oglr.validateContext(sg2d);
	134	}
	135	public void drawLine(SunGraphics2D sg2d,
	136	int x1, int y1, int x2, int y2)
	137	{
	138	GraphicsPrimitive.tracePrimitive("OGLDrawLine");
	139	oglr.drawLine(sg2d, x1, y1, x2, y2);
	140	}
	141	public void drawRect(SunGraphics2D sg2d, int x, int y, int w, int h) {
	142	GraphicsPrimitive.tracePrimitive("OGLDrawRect");
	143	oglr.drawRect(sg2d, x, y, w, h);
	144	}
	145	protected void drawPoly(SunGraphics2D sg2d,
	146	int[] xPoints, int[] yPoints,
	147	int nPoints, boolean isClosed)
	148	{
	149	GraphicsPrimitive.tracePrimitive("OGLDrawPoly");
	150	oglr.drawPoly(sg2d, xPoints, yPoints, nPoints, isClosed);
	151	}
	152	public void fillRect(SunGraphics2D sg2d, int x, int y, int w, int h) {
	153	GraphicsPrimitive.tracePrimitive("OGLFillRect");
	154	oglr.fillRect(sg2d, x, y, w, h);
	155	}
	156	protected void drawPath(SunGraphics2D sg2d,
	157	Path2D.Float p2df, int transx, int transy)
	158	{
	159	GraphicsPrimitive.tracePrimitive("OGLDrawPath");
	160	oglr.drawPath(sg2d, p2df, transx, transy);
	161	}
	162	protected void fillPath(SunGraphics2D sg2d,
	163	Path2D.Float p2df, int transx, int transy)
	164	{
	165	GraphicsPrimitive.tracePrimitive("OGLFillPath");
	166	oglr.fillPath(sg2d, p2df, transx, transy);
	167	}
	168	protected void fillSpans(SunGraphics2D sg2d, SpanIterator si,
	169	int transx, int transy)
	170	{
	171	GraphicsPrimitive.tracePrimitive("OGLFillSpans");
	172	oglr.fillSpans(sg2d, si, transx, transy);
	173	}
	174	public void fillParallelogram(SunGraphics2D sg2d,
	175	double ux1, double uy1,
	176	double ux2, double uy2,
	177	double x, double y,
	178	double dx1, double dy1,
	179	double dx2, double dy2)
	180	{
	181	GraphicsPrimitive.tracePrimitive("OGLFillParallelogram");
	182	oglr.fillParallelogram(sg2d,
	183	ux1, uy1, ux2, uy2,
	184	x, y, dx1, dy1, dx2, dy2);
	185	}
	186	public void drawParallelogram(SunGraphics2D sg2d,
	187	double ux1, double uy1,
	188	double ux2, double uy2,
	189	double x, double y,
	190	double dx1, double dy1,
	191	double dx2, double dy2,
	192	double lw1, double lw2)
	193	{
	194	GraphicsPrimitive.tracePrimitive("OGLDrawParallelogram");
	195	oglr.drawParallelogram(sg2d,
	196	ux1, uy1, ux2, uy2,
	197	x, y, dx1, dy1, dx2, dy2, lw1, lw2);
	198	}
	199	public void copyArea(SunGraphics2D sg2d,
	200	int x, int y, int w, int h, int dx, int dy)
	201	{
	202	GraphicsPrimitive.tracePrimitive("OGLCopyArea");
	203	oglr.copyArea(sg2d, x, y, w, h, dx, dy);
	204	}
	205	}
	206	}

java/pkg/sun/java2d/opengl/OGLSurfaceData.java+653−0

@@ -0,0 +1,653 @@
	1	/*
	2	* Copyright (c) 2003, 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.opengl;
	27
	28	import java.awt.AlphaComposite;
	29	import java.awt.GraphicsEnvironment;
	30	import java.awt.Rectangle;
	31	import java.awt.Transparency;
	32	import java.awt.image.ColorModel;
	33	import java.awt.image.Raster;
	34	import sun.awt.SunHints;
	35	import sun.awt.image.PixelConverter;
	36	import sun.java2d.pipe.hw.AccelSurface;
	37	import sun.java2d.SunGraphics2D;
	38	import sun.java2d.SurfaceData;
	39	import sun.java2d.SurfaceDataProxy;
	40	import sun.java2d.loops.CompositeType;
	41	import sun.java2d.loops.GraphicsPrimitive;
	42	import sun.java2d.loops.MaskFill;
	43	import sun.java2d.loops.SurfaceType;
	44	import sun.java2d.pipe.ParallelogramPipe;
	45	import sun.java2d.pipe.PixelToParallelogramConverter;
	46	import sun.java2d.pipe.RenderBuffer;
	47	import sun.java2d.pipe.TextPipe;
	48	import static sun.java2d.pipe.BufferedOpCodes.*;
	49	import static sun.java2d.opengl.OGLContext.OGLContextCaps.*;
	50
	51	/**
	52	* This class describes an OpenGL "surface", that is, a region of pixels
	53	* managed via OpenGL. An OGLSurfaceData can be tagged with one of three
	54	* different SurfaceType objects for the purpose of registering loops, etc.
	55	* This diagram shows the hierarchy of OGL SurfaceTypes:
	56	*
	57	* Any
	58	* / \
	59	* OpenGLSurface OpenGLTexture
	60	* \|
	61	* OpenGLSurfaceRTT
	62	*
	63	* OpenGLSurface
	64	* This kind of surface can be rendered to using OpenGL APIs. It is also
	65	* possible to copy an OpenGLSurface to another OpenGLSurface (or to itself).
	66	* This is typically accomplished by calling MakeContextCurrent(dstSD, srcSD)
	67	* and then calling glCopyPixels() (although there are other techniques to
	68	* achieve the same goal).
	69	*
	70	* OpenGLTexture
	71	* This kind of surface cannot be rendered to using OpenGL (in the same sense
	72	* as in OpenGLSurface). However, it is possible to upload a region of pixels
	73	* to an OpenGLTexture object via glTexSubImage2D(). One can also copy a
	74	* surface of type OpenGLTexture to an OpenGLSurface by binding the texture
	75	* to a quad and then rendering it to the destination surface (this process
	76	* is known as "texture mapping").
	77	*
	78	* OpenGLSurfaceRTT
	79	* This kind of surface can be thought of as a sort of hybrid between
	80	* OpenGLSurface and OpenGLTexture, in that one can render to this kind of
	81	* surface as if it were of type OpenGLSurface, but the process of copying
	82	* this kind of surface to another is more like an OpenGLTexture. (Note that
	83	* "RTT" stands for "render-to-texture".)
	84	*
	85	* In addition to these SurfaceType variants, we have also defined some
	86	* constants that describe in more detail the type of underlying OpenGL
	87	* surface. This table helps explain the relationships between those
	88	* "type" constants and their corresponding SurfaceType:
	89	*
	90	* OGL Type Corresponding SurfaceType
	91	* -------- -------------------------
	92	* WINDOW OpenGLSurface
	93	* PBUFFER OpenGLSurface
	94	* TEXTURE OpenGLTexture
	95	* FLIP_BACKBUFFER OpenGLSurface
	96	* FBOBJECT OpenGLSurfaceRTT
	97	*/
	98	public abstract class OGLSurfaceData extends SurfaceData
	99	implements AccelSurface {
	100
	101	/**
	102	* OGL-specific surface types
	103	*
	104	* @see sun.java2d.pipe.hw.AccelSurface
	105	*/
	106	public static final int PBUFFER = RT_PLAIN;
	107	public static final int FBOBJECT = RT_TEXTURE;
	108
	109	/**
	110	* Pixel formats
	111	*/
	112	public static final int PF_INT_ARGB = 0;
	113	public static final int PF_INT_ARGB_PRE = 1;
	114	public static final int PF_INT_RGB = 2;
	115	public static final int PF_INT_RGBX = 3;
	116	public static final int PF_INT_BGR = 4;
	117	public static final int PF_INT_BGRX = 5;
	118	public static final int PF_USHORT_565_RGB = 6;
	119	public static final int PF_USHORT_555_RGB = 7;
	120	public static final int PF_USHORT_555_RGBX = 8;
	121	public static final int PF_BYTE_GRAY = 9;
	122	public static final int PF_USHORT_GRAY = 10;
	123	public static final int PF_3BYTE_BGR = 11;
	124
	125	/**
	126	* SurfaceTypes
	127	*/
	128	private static final String DESC_OPENGL_SURFACE = "OpenGL Surface";
	129	private static final String DESC_OPENGL_SURFACE_RTT =
	130	"OpenGL Surface (render-to-texture)";
	131	private static final String DESC_OPENGL_TEXTURE = "OpenGL Texture";
	132
	133	static final SurfaceType OpenGLSurface =
	134	SurfaceType.Any.deriveSubType(DESC_OPENGL_SURFACE,
	135	PixelConverter.ArgbPre.instance);
	136	static final SurfaceType OpenGLSurfaceRTT =
	137	OpenGLSurface.deriveSubType(DESC_OPENGL_SURFACE_RTT);
	138	static final SurfaceType OpenGLTexture =
	139	SurfaceType.Any.deriveSubType(DESC_OPENGL_TEXTURE);
	140
	141	/** This will be true if the fbobject system property has been enabled. */
	142	private static boolean isFBObjectEnabled;
	143
	144	/** This will be true if the lcdshader system property has been enabled.*/
	145	private static boolean isLCDShaderEnabled;
	146
	147	/** This will be true if the biopshader system property has been enabled.*/
	148	private static boolean isBIOpShaderEnabled;
	149
	150	/** This will be true if the gradshader system property has been enabled.*/
	151	private static boolean isGradShaderEnabled;
	152
	153	private OGLGraphicsConfig graphicsConfig;
	154	protected int type;
	155	// these fields are set from the native code when the surface is
	156	// initialized
	157	private int nativeWidth, nativeHeight;
	158
	159	protected static OGLRenderer oglRenderPipe;
	160	protected static PixelToParallelogramConverter oglTxRenderPipe;
	161	protected static ParallelogramPipe oglAAPgramPipe;
	162	protected static OGLTextRenderer oglTextPipe;
	163	protected static OGLDrawImage oglImagePipe;
	164
	165	protected native boolean initTexture(long pData,
	166	boolean isOpaque, boolean texNonPow2,
	167	boolean texRect,
	168	int width, int height);
	169	protected native boolean initFBObject(long pData,
	170	boolean isOpaque, boolean texNonPow2,
	171	boolean texRect,
	172	int width, int height);
	173	protected native boolean initFlipBackbuffer(long pData);
	174	protected abstract boolean initPbuffer(long pData, long pConfigInfo,
	175	boolean isOpaque,
	176	int width, int height);
	177
	178	private native int getTextureTarget(long pData);
	179	private native int getTextureID(long pData);
	180
	181	static {
	182	if (!GraphicsEnvironment.isHeadless()) {
	183	// fbobject currently enabled by default; use "false" to disable
	184	String fbo = (String)java.security.AccessController.doPrivileged(
	185	new sun.security.action.GetPropertyAction(
	186	"sun.java2d.opengl.fbobject"));
	187	isFBObjectEnabled = !"false".equals(fbo);
	188
	189	// lcdshader currently enabled by default; use "false" to disable
	190	String lcd = (String)java.security.AccessController.doPrivileged(
	191	new sun.security.action.GetPropertyAction(
	192	"sun.java2d.opengl.lcdshader"));
	193	isLCDShaderEnabled = !"false".equals(lcd);
	194
	195	// biopshader currently enabled by default; use "false" to disable
	196	String biop = (String)java.security.AccessController.doPrivileged(
	197	new sun.security.action.GetPropertyAction(
	198	"sun.java2d.opengl.biopshader"));
	199	isBIOpShaderEnabled = !"false".equals(biop);
	200
	201	// gradshader currently enabled by default; use "false" to disable
	202	String grad = (String)java.security.AccessController.doPrivileged(
	203	new sun.security.action.GetPropertyAction(
	204	"sun.java2d.opengl.gradshader"));
	205	isGradShaderEnabled = !"false".equals(grad);
	206
	207	OGLRenderQueue rq = OGLRenderQueue.getInstance();
	208	oglImagePipe = new OGLDrawImage();
	209	oglTextPipe = new OGLTextRenderer(rq);
	210	oglRenderPipe = new OGLRenderer(rq);
	211	if (GraphicsPrimitive.tracingEnabled()) {
	212	oglTextPipe = oglTextPipe.traceWrap();
	213	//The wrapped oglRenderPipe will wrap the AA pipe as well...
	214	//oglAAPgramPipe = oglRenderPipe.traceWrap();
	215	}
	216	oglAAPgramPipe = oglRenderPipe.getAAParallelogramPipe();
	217	oglTxRenderPipe =
	218	new PixelToParallelogramConverter(oglRenderPipe,
	219	oglRenderPipe,
	220	1.0, 0.25, true);
	221
	222	OGLBlitLoops.register();
	223	OGLMaskFill.register();
	224	OGLMaskBlit.register();
	225	}
	226	}
	227
	228	protected OGLSurfaceData(OGLGraphicsConfig gc,
	229	ColorModel cm, int type)
	230	{
	231	super(getCustomSurfaceType(type), cm);
	232	this.graphicsConfig = gc;
	233	this.type = type;
	234	setBlitProxyKey(gc.getProxyKey());
	235	}
	236
	237	@Override
	238	public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {
	239	return OGLSurfaceDataProxy.createProxy(srcData, graphicsConfig);
	240	}
	241
	242	/**
	243	* Returns the appropriate SurfaceType corresponding to the given OpenGL
	244	* surface type constant (e.g. TEXTURE -> OpenGLTexture).
	245	*/
	246	private static SurfaceType getCustomSurfaceType(int oglType) {
	247	switch (oglType) {
	248	case TEXTURE:
	249	return OpenGLTexture;
	250	case FBOBJECT:
	251	return OpenGLSurfaceRTT;
	252	case PBUFFER:
	253	default:
	254	return OpenGLSurface;
	255	}
	256	}
	257

396 more lines aren’t shown here.

java/pkg/sun/java2d/opengl/OGLSurfaceDataProxy.java+81−0

This diff is large: its 82 lines aren’t shown here.

java/pkg/sun/java2d/opengl/OGLTextRenderer.java+71−0

This diff is large: its 72 lines aren’t shown here.

java/pkg/sun/java2d/opengl/OGLUtilities.java+338−0

This diff is large: its 339 lines aren’t shown here.

java/pkg/sun/java2d/opengl/mkfile+21−0

This diff is large: its 22 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 216 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 46 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 112 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 91 lines aren’t shown here.

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

This diff is large: its 207 lines aren’t shown here.

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

This diff is large: its 394 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 471 lines aren’t shown here.

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

This diff is large: its 164 lines aren’t shown here.

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

This diff is large: its 154 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 100 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 534 lines aren’t shown here.

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

This diff is large: its 602 lines aren’t shown here.

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

This diff is large: its 169 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 51 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 1111 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 87 lines aren’t shown here.

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

This diff is large: its 155 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 61 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 148 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 45 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 38 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 379 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 156 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 146 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 77 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 68 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 62 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 430 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 134 lines aren’t shown here.

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

This diff is large: its 1256 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 393 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 102 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 211 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 295 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 224 lines aren’t shown here.

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

This diff is large: its 483 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 41 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 202 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 45 lines aren’t shown here.

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

This diff is large: its 142 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 96 lines aren’t shown here.

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

This diff is large: its 217 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 50 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 99 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 242 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 60 lines aren’t shown here.

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

This diff is large: its 168 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 96 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 137 lines aren’t shown here.

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

This diff is large: its 75 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 46 lines aren’t shown here.

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

Binary file not shown.

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

This diff is large: its 129 lines aren’t shown here.

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

This diff is large: its 155 lines aren’t shown here.

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

This diff is large: its 16 lines aren’t shown here.

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

This diff is large: its 57 lines aren’t shown here.

java/pkg/sun/java2d/pisces/Curve.java+290−0

This diff is large: its 291 lines aren’t shown here.

java/pkg/sun/java2d/pisces/Dasher.java+575−0

This diff is large: its 576 lines aren’t shown here.

java/pkg/sun/java2d/pisces/Helpers.java+458−0

This diff is large: its 459 lines aren’t shown here.

java/pkg/sun/java2d/pisces/META-INF/mkfile+6−0

This diff is large: its 7 lines aren’t shown here.

java/pkg/sun/java2d/pisces/META-INF/services/mkfile+2−0

This diff is large: its 3 lines aren’t shown here.

java/pkg/sun/java2d/pisces/META-INF/services/sun.java2d.pipe.RenderingEngine+2−0

This diff is large: its 3 lines aren’t shown here.

java/pkg/sun/java2d/pisces/PiscesCache.java+186−0

This diff is large: its 187 lines aren’t shown here.

java/pkg/sun/java2d/pisces/PiscesRenderingEngine.java+656−0

This diff is large: its 657 lines aren’t shown here.

java/pkg/sun/java2d/pisces/PiscesTileGenerator.java+252−0

This diff is large: its 253 lines aren’t shown here.

java/pkg/sun/java2d/pisces/Renderer.java+571−0

This diff is large: its 572 lines aren’t shown here.

java/pkg/sun/java2d/pisces/Stroker.java+1223−0

This diff is large: its 1224 lines aren’t shown here.

java/pkg/sun/java2d/pisces/TransformingPathConsumer2D.java+393−0

This diff is large: its 394 lines aren’t shown here.

java/pkg/sun/java2d/pisces/mkfile+20−0

This diff is large: its 21 lines aren’t shown here.