Back to index...

	/*
	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	* @author Charlton Innovations, Inc.
	*/

	package sun.java2d.loops;

	import java.util.Comparator;
	import java.util.Arrays;
	import sun.java2d.SunGraphics2D;

	/**
	* GraphicsComponentMgr provides services to
	* 1. register primitives for later use
	* 2. locate an instance of a primitve based on characteristics
	*/
	public final class GraphicsPrimitiveMgr {

	private static final boolean debugTrace = false;
	private static GraphicsPrimitive primitives[];
	private static GraphicsPrimitive generalPrimitives[];
	private static boolean needssort = true;

	private static native void initIDs(Class GP, Class ST, Class CT,
	Class SG2D, Class Color, Class AT,
	Class XORComp, Class AlphaComp,
	Class Path2D, Class Path2DFloat,
	Class SHints);
	private static native void registerNativeLoops();

	static {
	initIDs(GraphicsPrimitive.class,
	SurfaceType.class,
	CompositeType.class,
	SunGraphics2D.class,
	java.awt.Color.class,
	java.awt.geom.AffineTransform.class,
	XORComposite.class,
	java.awt.AlphaComposite.class,
	java.awt.geom.Path2D.class,
	java.awt.geom.Path2D.Float.class,
	sun.awt.SunHints.class);
	CustomComponent.register();
	GeneralRenderer.register();
	registerNativeLoops();
	}

	private static class PrimitiveSpec {
	public int uniqueID;
	}

	private static Comparator primSorter = new Comparator() {
	public int compare(Object o1, Object o2) {
	int id1 = ((GraphicsPrimitive) o1).getUniqueID();
	int id2 = ((GraphicsPrimitive) o2).getUniqueID();

	return (id1 == id2 ? 0 : (id1 < id2 ? -1 : 1));
	}
	};

	private static Comparator primFinder = new Comparator() {
	public int compare(Object o1, Object o2) {
	int id1 = ((GraphicsPrimitive) o1).getUniqueID();
	int id2 = ((PrimitiveSpec) o2).uniqueID;

	return (id1 == id2 ? 0 : (id1 < id2 ? -1 : 1));
	}
	};

	/**
	* Ensure that noone can instantiate this class.
	*/
	private GraphicsPrimitiveMgr() {
	}

	public synchronized static void register(GraphicsPrimitive[] newPrimitives)
	{
	GraphicsPrimitive[] devCollection = primitives;
	int oldSize = 0;
	int newSize = newPrimitives.length;
	if (debugTrace) {
	writeLog("Registering " + newSize + " primitives");
	for (int i = 0; i < newSize; i++) {
	writeLog(newPrimitives[i].toString());
	}
	}
	if (devCollection != null) {
	oldSize = devCollection.length;
	}
	GraphicsPrimitive[] temp = new GraphicsPrimitive[oldSize + newSize];
	if (devCollection != null) {
	System.arraycopy(devCollection, 0, temp, 0, oldSize);
	}
	System.arraycopy(newPrimitives, 0, temp, oldSize, newSize);
	needssort = true;
	primitives = temp;
	}

	public synchronized static void registerGeneral(GraphicsPrimitive gen) {
	if (generalPrimitives == null) {
	generalPrimitives = new GraphicsPrimitive[] {gen};
	return;
	}
	int len = generalPrimitives.length;
	GraphicsPrimitive[] newGen = new GraphicsPrimitive[len + 1];
	System.arraycopy(generalPrimitives, 0, newGen, 0, len);
	newGen[len] = gen;
	generalPrimitives = newGen;
	}

	public synchronized static GraphicsPrimitive locate(int primTypeID,
	SurfaceType dsttype)
	{
	return locate(primTypeID,
	SurfaceType.OpaqueColor,
	CompositeType.Src,
	dsttype);
	}

	public synchronized static GraphicsPrimitive locate(int primTypeID,
	SurfaceType srctype,
	CompositeType comptype,
	SurfaceType dsttype)
	{
	/*
	System.out.println("Looking for:");
	System.out.println(" method: "+signature);
	System.out.println(" from: "+srctype);
	System.out.println(" by: "+comptype);
	System.out.println(" to: "+dsttype);
	*/
	GraphicsPrimitive prim = locatePrim(primTypeID,
	srctype, comptype, dsttype);

	if (prim == null) {
	//System.out.println("Trying general loop");
	prim = locateGeneral(primTypeID);
	if (prim != null) {
	prim = prim.makePrimitive(srctype, comptype, dsttype);
	if (prim != null && GraphicsPrimitive.traceflags != 0) {
	prim = prim.traceWrap();
	}
	}
	}
	return prim;
	}

	public synchronized static GraphicsPrimitive
	locatePrim(int primTypeID,
	SurfaceType srctype,
	CompositeType comptype,
	SurfaceType dsttype)
	{
	/*
	System.out.println("Looking for:");
	System.out.println(" method: "+signature);
	System.out.println(" from: "+srctype);
	System.out.println(" by: "+comptype);
	System.out.println(" to: "+dsttype);
	*/
	SurfaceType src, dst;
	CompositeType cmp;
	GraphicsPrimitive prim;
	PrimitiveSpec spec = new PrimitiveSpec();

	for (dst = dsttype; dst != null; dst = dst.getSuperType()) {
	for (src = srctype; src != null; src = src.getSuperType()) {
	for (cmp = comptype; cmp != null; cmp = cmp.getSuperType()) {
	/*
	System.out.println("Trying:");
	System.out.println(" method: "+spec.methodSignature);
	System.out.println(" from: "+spec.sourceType);
	System.out.println(" by: "+spec.compType);
	System.out.println(" to: "+spec.destType);
	*/

	spec.uniqueID =
	GraphicsPrimitive.makeUniqueID(primTypeID, src, cmp, dst);
	prim = locate(spec);
	if (prim != null) {
	//System.out.println("<GPMgr> Found: " + prim + " in " + i + " steps");
	return prim;
	}
	}
	}
	}
	return null;
	}

	private static GraphicsPrimitive locateGeneral(int primTypeID) {
	if (generalPrimitives == null) {
	return null;
	}
	for (int i = 0; i < generalPrimitives.length; i++) {
	GraphicsPrimitive prim = generalPrimitives[i];
	if (prim.getPrimTypeID() == primTypeID) {
	return prim;
	}
	}
	return null;
	//throw new InternalError("No general handler registered for"+signature);
	}

	private static GraphicsPrimitive locate(PrimitiveSpec spec) {
	if (needssort) {
	if (GraphicsPrimitive.traceflags != 0) {
	for (int i = 0; i < primitives.length; i++) {
	primitives[i] = primitives[i].traceWrap();
	}
	}
	Arrays.sort(primitives, primSorter);
	needssort = false;
	}
	GraphicsPrimitive[] devCollection = primitives;
	if (devCollection == null) {
	return null;
	}
	int index = Arrays.binarySearch(devCollection, spec, primFinder);
	if (index >= 0) {
	GraphicsPrimitive prim = devCollection[index];
	if (prim instanceof GraphicsPrimitiveProxy) {
	prim = ((GraphicsPrimitiveProxy) prim).instantiate();
	devCollection[index] = prim;
	if (debugTrace) {
	writeLog("Instantiated graphics primitive " + prim);
	}
	}
	if (debugTrace) {
	writeLog("Lookup found[" + index + "]["+ prim + "]");
	}
	return prim;
	}
	if (debugTrace) {
	writeLog("Lookup found nothing for:");
	writeLog(" " + spec.uniqueID);
	}
	return null;
	}

	private static void writeLog(String str) {
	if (debugTrace) {
	System.err.println(str);
	}
	}

	/**
	* Test that all of the GraphicsPrimitiveProxy objects actually
	* resolve to something. Throws a RuntimeException if anything
	* is wrong, an has no effect if all is well.
	*/
	// This is only really meant to be called from GraphicsPrimitiveProxyTest
	// in the regression tests directory, but it has to be here because
	// it needs access to a private data structure. It is not very
	// big, though.
	public static void testPrimitiveInstantiation() {
	testPrimitiveInstantiation(false);
	}

	public static void testPrimitiveInstantiation(boolean verbose) {
	int resolved = 0;
	int unresolved = 0;
	GraphicsPrimitive[] prims = primitives;
	for (int j = 0; j < prims.length; j++) {
	GraphicsPrimitive p = prims[j];
	if (p instanceof GraphicsPrimitiveProxy) {
	GraphicsPrimitive r = ((GraphicsPrimitiveProxy) p).instantiate();
	if (!r.getSignature().equals(p.getSignature()) \|\|
	r.getUniqueID() != p.getUniqueID()) {
	System.out.println("r.getSignature == "+r.getSignature());
	System.out.println("r.getUniqueID == " + r.getUniqueID());
	System.out.println("p.getSignature == "+p.getSignature());
	System.out.println("p.getUniqueID == " + p.getUniqueID());
	throw new RuntimeException("Primitive " + p
	+ " returns wrong signature for "
	+ r.getClass());
	}
	// instantiate checks that p.satisfiesSameAs(r)
	unresolved++;
	p = r;
	if (verbose) {
	System.out.println(p);
	}
	} else {
	if (verbose) {
	System.out.println(p + " (not proxied).");
	}
	resolved++;
	}
	}
	System.out.println(resolved+
	" graphics primitives were not proxied.");
	System.out.println(unresolved+
	" proxied graphics primitives resolved correctly.");
	System.out.println(resolved+unresolved+
	" total graphics primitives");
	}

	public static void main(String argv[]) {
	// REMIND: Should trigger loading of platform primitives somehow...
	if (needssort) {
	Arrays.sort(primitives, primSorter);
	needssort = false;
	}
	testPrimitiveInstantiation(argv.length > 0);
	}
	}

Back to index...