X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.eclipse.swt.win32.win32.x86_64%2Fsrc%2Forg%2Feclipse%2Fswt%2Finternal%2FCallback.java;fp=bundles%2Forg.eclipse.swt.win32.win32.x86_64%2Fsrc%2Forg%2Feclipse%2Fswt%2Finternal%2FCallback.java;h=2248861bae8067dcffd51482fd597ea1d9a2e96d;hb=6b98970d0458754dd67f789afbd0a39e1e7ac6eb;hp=0000000000000000000000000000000000000000;hpb=56a61575ce0d27b340cb12438c8a7f303842095e;p=simantics%2Fplatform.git diff --git a/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/internal/Callback.java b/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/internal/Callback.java new file mode 100644 index 000000000..2248861ba --- /dev/null +++ b/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/internal/Callback.java @@ -0,0 +1,361 @@ +/******************************************************************************* + * Copyright (c) 2000, 2012 IBM Corporation and others. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.internal; + +import java.lang.reflect.*; +import java.util.function.*; + +import org.eclipse.swt.*; + +/** + * Instances of this class represent entry points into Java + * which can be invoked from operating system level callback + * routines. + *
+ * IMPORTANT: A callback is only valid when invoked on the
+ * thread which created it. The results are undefined (and
+ * typically bad) when a callback is passed out to the
+ * operating system (or other code) in such a way that the
+ * callback is called from a different thread.
+ */
+
+public class Callback {
+
+ Object object;
+ String method, signature;
+ int argCount;
+ long address, errorResult;
+ boolean isStatic, isArrayBased;
+
+ static final boolean is32Bit = C.PTR_SIZEOF == 4 ? true : false;
+ static final String PTR_SIGNATURE = is32Bit ? "I" : "J"; //$NON-NLS-1$ //$NON-NLS-2$
+ static final String SIGNATURE_0 = getSignature(0);
+ static final String SIGNATURE_1 = getSignature(1);
+ static final String SIGNATURE_2 = getSignature(2);
+ static final String SIGNATURE_3 = getSignature(3);
+ static final String SIGNATURE_4 = getSignature(4);
+ static final String SIGNATURE_N = "(["+PTR_SIGNATURE+")"+PTR_SIGNATURE; //$NON-NLS-1$ //$NON-NLS-2$
+
+/**
+ * Constructs a new instance of this class given an object
+ * to send the message to, a string naming the method to
+ * invoke and an argument count. Note that, if the object
+ * is an instance of Class
it is assumed that
+ * the method is a static method on that class.
+ *
+ *
Note, do not use this if the method arguments have a double, as arguments will be
+ * shifted/corrupted. See Bug 510538. Instead use the following constructor:
+ * Callback (Object, String, Type, Type [])
Class
+ * it is assumed that the method is a static method on that
+ * class.
+ *
+ * Note, do not use this if the method arguments have a double, as arguments will be
+ * shifted/corrupted. See Bug 510538. Instead use the following constructor:
+ * Callback (Object, String, Type, Type [])
true
if the arguments should be passed in an array and false otherwise
+ */
+public Callback (Object object, String method, int argCount, boolean isArrayBased) {
+ this (object, method, argCount, isArrayBased, 0);
+}
+
+/**
+ * Constructs a new instance of this class given an object
+ * to send the message to, a string naming the method to
+ * invoke, an argument count, a flag indicating whether
+ * or not the arguments will be passed in an array and a value
+ * to return when an exception happens. Note that, if
+ * the object is an instance of Class
+ * it is assumed that the method is a static method on that
+ * class.
+ *
+ * Note, do not use this if the method arguments have a double, as arguments will be
+ * shifted/corrupted. See Bug 510538. Instead use the following constructor:
+ * Callback (Object, String, Type, Type [])
true
if the arguments should be passed in an array and false otherwise
+ * @param errorResult the return value if the java code throws an exception
+ */
+public Callback (Object object, String method, int argCount, boolean isArrayBased, long errorResult) {
+
+ /* Set the callback fields */
+ this.object = object;
+ this.method = method;
+ this.argCount = argCount;
+ this.isStatic = object instanceof Class;
+ this.isArrayBased = isArrayBased;
+ this.errorResult = errorResult;
+
+ /* Inline the common cases */
+ if (isArrayBased) {
+ signature = SIGNATURE_N;
+ } else {
+ switch (argCount) {
+ case 0: signature = SIGNATURE_0; break; //$NON-NLS-1$
+ case 1: signature = SIGNATURE_1; break; //$NON-NLS-1$
+ case 2: signature = SIGNATURE_2; break; //$NON-NLS-1$
+ case 3: signature = SIGNATURE_3; break; //$NON-NLS-1$
+ case 4: signature = SIGNATURE_4; break; //$NON-NLS-1$
+ default:
+ signature = getSignature(argCount);
+ }
+ }
+
+ /* Bind the address */
+ address = bind (this, object, method, signature, argCount, isStatic, isArrayBased, errorResult);
+}
+
+
+/**
+ * Register the java method to be a C callback. + * I.e, C will be able to make a call to this java method directly (through callback.c)
+ * + *The other constructors hard-code int/long into the method signature:
+ * long method (long ...)
+ * Which is suitable for int/long and pointers.
+ * This constructor is used if you need to use a different return/argument type, e.g double. See Bug 510538
Note: + *
Class
it is assumed that
+ * the method is a static method on that class. long /*int*/
The following types are supported:
+ *
For example if you want to link the following method:
+ * void myMethod(long /*int*/ arg1, double arg2)
+ * Then you would call this callback like:
+ * Callback (this, "myMethod", void.class, new Type []{long.class, double.class});
+ *
void.class, long.class, double.class
+ * @param arguments specify the list of arguments like new Type [] {long.class, double.class }
+ */
+public Callback (Object object, String method, Type returnType, Type [] arguments) {
+ /* Set the callback fields */
+ this.object = object;
+ this.method = method;
+ this.argCount = arguments != null ? arguments.length : 0;
+ this.isStatic = object instanceof Class;
+ this.isArrayBased = false;
+ this.errorResult = 0;
+
+ Function + * Note: This should not be called by application code. + *
+ * + * @return the entry count + * + * @since 2.1 + */ +public static native int getEntryCount (); + +static String getSignature(int argCount) { + String signature = "("; //$NON-NLS-1$ + for (int i = 0; i < argCount; i++) signature += PTR_SIGNATURE; + signature += ")" + PTR_SIGNATURE; //$NON-NLS-1$ + return signature; +} + +/** + * Indicates whether or not callbacks which are triggered at the + * native level should cause the messages described by the matching + *Callback
objects to be invoked. This method is used
+ * to safely shut down SWT when it is run within environments
+ * which can generate spurious events.
+ * + * Note: This should not be called by application code. + *
+ * + * @param enable true if callbacks should be invoked + */ +public static final native synchronized void setEnabled (boolean enable); + +/** + * Returns whether or not callbacks which are triggered at the + * native level should cause the messages described by the matching + *Callback
objects to be invoked. This method is used
+ * to safely shut down SWT when it is run within environments
+ * which can generate spurious events.
+ * + * Note: This should not be called by application code. + *
+ * + * @return true if callbacks should not be invoked + */ +public static final native synchronized boolean getEnabled (); + +/** + * This might be called directly from native code in environments + * which can generate spurious events. Check before removing it. + * + * @deprecated + * + * @param ignore true if callbacks should not be invoked + */ +@Deprecated +static final void ignoreCallbacks (boolean ignore) { + setEnabled (!ignore); +} + +/** + * Immediately wipes out all native level state associated + * with all callbacks. + *+ * WARNING: This operation is extremely dangerous, + * and should never be performed by application code. + *
+ */ +public static final native synchronized void reset (); + +/** + * Releases the native level resources associated with the callback. + * + * @see #dispose + */ +static final native synchronized void unbind (Callback callback); + +}