Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebindings@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 285 insertions, 0 deletions

diff --git a/qtjava/javalib/org/kde/qt/qtjava.java b/qtjava/javalib/org/kde/qt/qtjava.java
new file mode 100644
index 00000000..8547776c
--- /dev/null
+++ b/qtjava/javalib/org/kde/qt/qtjava.java
@@ -0,0 +1,285 @@
+/***************************************************************************
+                            qtjava.java -  description
+                             -------------------
+    begin                : Tue Oct 31 06:12:14 2000
+    copyright            : (C) 2000 Lost Highway Ltd. All rights reserved.
+    email                : Lost_Highway@tipitina.demon.co.uk
+    written by           : Richard Dale.
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+package org.kde.qt;
+
+import java.util.*;
+import java.lang.Error;
+
+/** The 'Run the Qt Java library' class'. Various utility methods to manage
+	the mapping between C++ and java instances. Used in conjunction the C++ methods
+	in QtSupport.cpp and JavaSlot.cpp.
+	
+	@author Richard Dale <Richard_Dale@tipitina.demon.co.uk>
+	*/
+public class qtjava {
+	/** Uses a C++ key to retrieve the corresponding Java instance */
+	public static WeakValueMap	qtKeyToJavaMap = null;
+	
+	/** Allows a JavaSignal proxy instance to be retrieved for a given Java
+		instance/Signal name combination */
+	public static HashMap 		qtSignalDictionary = null;
+	
+	/** Allows a JavaSlot proxy instance to be retrieved for a given Java
+		instance/Slot name combination */
+	public static HashMap 		qtSlotDictionary = null;
+	
+	/** Register a JavaVM pointer to make it easy to retrieve the current
+		JNIEnv later */
+	private native static void registerJVM();
+	
+	/** Get/set the C++ instance for a given Java instance */
+	private native static void setQt(Object obj, long qt);
+	private native static long getQt(Object obj);
+	
+	/** If a C++ instance has been allocated in the Java World, it will
+		be deleted within the corresponding Java instance's finalize method.  */
+	private native static void setAllocatedInJavaWorld(Object obj, boolean yn);
+	private native static boolean allocatedInJavaWorld(Object obj);
+	
+	/** This member allows a typecast of an instance which wraps a
+		Qt instance, to a more specialized type. */
+	private static QtSupport dynamicCast(String type, QtSupport source) {
+		boolean sourceAllocatedInJavaWorld	= allocatedInJavaWorld(source);
+		long	qtHandle					= getQt(source);
+
+		removeObjectForQtKey(qtHandle);
+		setAllocatedInJavaWorld(source, false);
+		return (QtSupport) objectForQtKey(qtHandle, type, sourceAllocatedInJavaWorld);
+	}
+	
+	/** Add a 'C++ qt instance key/Java instance value' pair to the map */
+	public static void setObjectForQtKey(Object obj, long qt) {
+		qtKeyToJavaMap.put(Long.toString(qt).intern(), obj);
+		return;
+	}
+
+	/** Remove a 'C++ qt instance key/Java instance value' pair from the map.
+		Normally an entry would be removed when its map value is the last reference
+		left to the java instance, and it becomes a weak reference to be reaped.
+		But C++ can reuse a heap address for a C++ ref without giving the java runtime
+		a chance to do any garbage collection and tidy up the corresponding entry in the
+		qtKeyToJavaMap (tricky!).
+		
+		So it is useful to be able to force the early removal of an entry, when the C++
+		instance has a known lifetime (eg a QEvent after its event handler has
+		returned).
+	 */
+	public static void removeObjectForQtKey(long qt) {
+		qtKeyToJavaMap.remove(Long.toString(qt).intern());
+		return;
+	}
+
+	/** Allocates an instance of a class without initializing it */
+	private native static Object allocateInstance(Class cls) throws InstantiationException, IllegalAccessException;
+	
+	/** If the C++ qt instance is an instance of QObject, then
+		use the Qt runtime meta-data to retrieve the class name.
+		If there is a Java class with the same name, then return
+		a Class object for that class. Otherwise, just return the
+		original 'approximate' Class passed to the method.
+		
+		Note that a java equivalent of the C++ instance doesn't have
+		to be instantiated to do this */
+	private native static Class classFromQtMetaData(Class approximateClass, String approximateClassName, long qt);
+	
+	/** Retrieves a corresponding Java instance for a given C++ instance. Allocates
+		the Java instance if it doesn't already exist. */
+	public static Object objectForQtKey(long qt, String className, boolean allocatedInJavaWorld) {
+		Object	result;
+		Class	aClass;
+		
+		result = qtKeyToJavaMap.get(Long.toString(qt).intern());
+
+		if (result == null) {
+			try {
+				aClass = Class.forName(toFullyQualifiedClassName(className));
+			} catch (ClassNotFoundException e) {
+				Qt.qWarning("Error class not found: " + toFullyQualifiedClassName(className));
+				return null;
+			}
+			
+			if (QtSupport.class.isAssignableFrom(aClass)) {
+				if (QObject.class.isAssignableFrom(aClass)) {
+					aClass = qtjava.classFromQtMetaData(aClass, aClass.getName(), qt);
+				}
+			
+				try {
+					result = qtjava.allocateInstance(aClass);
+				} catch (InstantiationException e) {
+					Qt.qWarning("Can't instantiate : " + toFullyQualifiedClassName(className));
+					return null;
+				} catch (IllegalAccessException e) {
+					Qt.qWarning("Illegal access to class : " + toFullyQualifiedClassName(className));
+					return null;
+				}
+			
+				setQt(result, qt);
+				setAllocatedInJavaWorld(result, allocatedInJavaWorld);
+			} else {
+				// A Java instance without a wrapped Qt C++ instance (eg a list)
+				try {
+					result = aClass.newInstance();
+				} catch (InstantiationException e) {
+					return null;
+				} catch (IllegalAccessException e) {
+					return null;
+				}
+			}
+			
+			setObjectForQtKey(result, qt);
+		}
+		
+		return result;
+	}
+	
+	/** When a C++ instance has been deleted. Retrieves a corresponding Java instance for a given C++ instance. Sets
+		the '_allocatedInJavaWorld' flag to false. */
+	public static void qtKeyDeleted(long qt) {
+		Object result = qtKeyToJavaMap.get(Long.toString(qt).intern());
+
+		if (	result != null
+				&& QtSupport.class.isAssignableFrom(result.getClass()) )
+		{
+			setAllocatedInJavaWorld(result, false);
+		}
+	}
+	
+	/** Converts any unqualified class names in a signal or slot string to the fully qualified versions */
+	public static String toFullyQualifiedClassName(String className) {
+		if (className.equals("String")) {
+			return "java.lang.String";
+		} else if (className.equals("Date")) {
+			return "java.util.Date";
+		} else if (className.equals("Calendar")) {
+			return "java.util.GregorianCalendar";
+		} else if (className.equals("ArrayList")) {
+			return "java.util.ArrayList";
+		} else if (className.equals("ByteArrayOutputStream")) {
+			return "java.io.ByteArrayOutputStream";
+		} else if (className.equals("Job")) {
+			return "org.kde.koala.Job";
+		} else if (className.equals("Part")) {
+			return "org.kde.koala.Part";
+		} else if (className.equals("Slave")) {
+			return "org.kde.koala.Slave";
+		} else if (className.equals("DOMNode")) {
+			return "org.kde.koala.DOMNode";
+		} else if (className.startsWith("Q")) {
+			return "org.kde.qt." + className;
+		} else if (className.startsWith("K")) {
+			return "org.kde.koala." + className;
+		}
+		return className;
+	}
+		
+	/** Converts from a list Java types in a signal or slot string, to the fully qualified equivalent */
+	private static String toNormalizedTypeSignature(String typeSignature) {
+		StringBuffer normalizedTypeSignature = new StringBuffer(	typeSignature.substring(	0,
+																	typeSignature.indexOf('(') + 1 ) );
+		StringTokenizer tokenizer = new StringTokenizer(	typeSignature.substring(	typeSignature.indexOf('(') + 1,
+																						typeSignature.indexOf(')') ),
+															"," );
+		
+		while (tokenizer.hasMoreTokens()) {
+			String token = tokenizer.nextToken();
+			
+			if (	token.equals("boolean")
+					|| token.equals("byte")
+					|| token.equals("char")
+					|| token.equals("long")
+					|| token.equals("int")
+					|| token.equals("short")
+					|| token.equals("float")
+					|| token.equals("double") )
+			{
+				normalizedTypeSignature.append(token);
+			} else {
+				normalizedTypeSignature.append(toFullyQualifiedClassName(token));
+			}
+			
+			if (tokenizer.hasMoreTokens()) {
+				normalizedTypeSignature.append(",");
+			}
+		}
+		
+		normalizedTypeSignature.append(")");
+		return normalizedTypeSignature.toString();
+	}
+
+	/** Returns a new C++ JavaSignal proxy instance, to forward the signal
+		onto the target Java slot */
+	private native static long newJavaSignal();
+	
+	/** Looks up a 'qt instance/signal name' key and returns the corresponding
+		JavaSignal instance */
+	public static long signalForSender(long qt, String signal) {
+		String normalizedSignal = toNormalizedTypeSignature(signal);
+		String key = (Long.toString(qt) +  normalizedSignal).intern();
+		Long result = (Long) qtSignalDictionary.get(key);
+		
+		if (result == null) {
+			long javaSignal = newJavaSignal();
+			qtSignalDictionary.put(key, new Long(javaSignal));
+			return javaSignal;
+		} else {
+			return result.longValue();
+		}
+	}
+	
+	/** Initialises the JavaSlot factory */
+	private native static void setJavaSlotFactory();
+	
+	/** Returns a new C++ JavaSlot proxy instance, to receive signals
+		and invoke the target Java slot */
+	private native static long newJavaSlot(QObject receiver, String member);
+	
+	/** Looks up a 'qt instance/slot name' key and returns the corresponding
+		JavaSlot instance */
+	public static long slotForReceiver(long qt, QObject receiver, String slot) {
+		String normalizedSlot = toNormalizedTypeSignature(slot);
+		String key = (Long.toString(qt) +  normalizedSlot).intern();
+		Long result = (Long) qtSlotDictionary.get(key);
+		
+		if (result == null) {
+			long javaSlot = newJavaSlot(receiver, normalizedSlot);
+			qtSlotDictionary.put(key, new Long(javaSlot));
+			return javaSlot;
+		} else {
+			return result.longValue();
+		}
+	}
+	
+	private static boolean _initialized = false;
+	
+	public static void initialize() {
+		if (!_initialized) {
+			System.loadLibrary("qtjava");
+			qtjava.registerJVM();
+			qtjava.setJavaSlotFactory();
+			qtKeyToJavaMap = new WeakValueMap();
+			qtSignalDictionary = new HashMap();
+			qtSlotDictionary = new HashMap();
+			_initialized = true;
+		}
+	}
+	
+	static {
+		initialize();
+	}
+}