--- a/dwt/internal/c/callback.d	Sat Aug 09 17:00:02 2008 +0200
+++ b/dwt/internal/c/callback.d	Tue Aug 19 17:35:17 2008 +0200
@@ -13,8 +13,31 @@
  *******************************************************************************/
 module dwt.internal.c.callback;
 
+/**
+ * Callback implementation.
+ */
+import dwt.dwthelper.utils;
 import dwt.internal.Callback;
 
+/* Header */
+
+version (Win32)
+{
+    import tango.sys.win32.UserGdi;
+    import tango.sys.win32.Types;
+}
+
+else version (Win32_WCE)
+{
+    import tango.sys.win32.UserGdi;
+    import tango.sys.win32.Types;
+}
+
+else
+    alias RETURN_TYPE SWT_PTR;
+
+/* Implementation */
+
 alias size_t SWT_PTR;
 
 struct CALLBACK_DATA 
@@ -41,7 +64,6 @@
     int initialized = 0;
 }
 
-
 SWT_PTR callback(int index, ...);
 
 static if (USE_ASSEMBLER)
@@ -55,10 +77,7 @@
     int CALLBACK_THUNK_SIZE = 64;
 }
 
-SWT_PTR Java_org_eclipse_swt_internal_Callback_bind (JNIEnv* env, jclass that,
-        jobject callbackObject, jobject object, jstring method,
-        jstring signature, jint argCount, jboolean isStatic,
-        jboolean isArrayBased, SWT_PTR errorResult)
+SWT_PTR bind (Callback callbackObject, Object object, String method, String signature, int argCount, boolean isStatic, boolean isArrayBased, SWT_PTR errorResult)
 {
     int i;
     jmethodID mid = null;
@@ -71,17 +90,15 @@
 
     if (!initialized)
     {
-        memset(&callbackData, 0, sizeof(callbackData));
+        memset(&callbackData, 0, callbackData.sizeof);
         initialized = 1;
     }
     
     if (method)
-        methodString = cast(/*const*/char*) (*env).GetStringUTFChars(env,
-                method, null);
+        methodString = cast(/*const*/char*) (*env).GetStringUTFChars(env, method, null);
     
     if (signature)
-        sigString = cast(/*const*/char*) (*env).GetStringUTFChars(env,
-                signature, null);
+        sigString = cast(/*const*/char*) (*env).GetStringUTFChars(env, signature, null);
     
     if (object && methodString && sigString)
     {
@@ -109,8 +126,7 @@
     {
         if (!callbackData[i].callback)
         {
-            if ((callbackData[i].callback = (*env).NewGlobalRef(env,
-                    callbackObject)) == null)
+            if ((callbackData[i].callback = (*env).NewGlobalRef(env, callbackObject)) == null)
                 goto fail;
             
             if ((callbackData[i].object = (*env).NewGlobalRef(env, object)) == null)
@@ -133,28 +149,21 @@
                 {
                     version (Win32)
                     {
-                        callbackCode = VirtualAlloc(null,
-                                CALLBACK_THUNK_SIZE * MAX_CALLBACKS,
-                                MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+                        callbackCode = VirtualAlloc(null, CALLBACK_THUNK_SIZE * MAX_CALLBACKS, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
                         if (callbackCode == null)
                             return 0;
                     }
 
                     else version (Win32_WCE)
                     {
-                        callbackCode = VirtualAlloc(null,
-                                CALLBACK_THUNK_SIZE * MAX_CALLBACKS,
-                                MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+                        callbackCode = VirtualAlloc(null, CALLBACK_THUNK_SIZE * MAX_CALLBACKS, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
                         if (callbackCode == null)
                             return 0;
                     }
 
                     else
                     {
-                        callbackCode = mmap(null,
-                                CALLBACK_THUNK_SIZE * MAX_CALLBACKS,
-                                PROT_EXEC | PROT_READ | PROT_WRITE,
-                                MAP_PRIVATE | MAP_ANON, -1, 0);
+                        callbackCode = mmap(null, CALLBACK_THUNK_SIZE * MAX_CALLBACKS, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
                         if (callbackCode == MAP_FAILED)
                             return 0;
                     }
@@ -171,7 +180,7 @@
                 version (darwin)
                 {
                     /* darwin calling conventions require that the stack be aligned on a 16-byte boundary. */
-                    k = (argCount + 3) * sizeof(SWT_PTR);
+                    k = (argCount + 3) * SWT_PTR.sizeof;
                     pad = ((k + 15) & ~15) - k;
                     if (pad > 0)
                     {
@@ -183,8 +192,7 @@
                 }
 
                 // 3*argCount bytes
-                for (k = (argCount + 1) * sizeof(SWT_PTR); k >= sizeof(SWT_PTR) * 2; k -= sizeof(
-                        SWT_PTR))
+                for (k = (argCount + 1) * SWT_PTR.sizeof; k >= SWT_PTR.sizeof * 2; k -= SWT_PTR.sizeof)
                 {
                     //PUSH SS:[EBP+k]
                     code[j++] = 0xff;
@@ -208,41 +216,40 @@
                     code[j++] = i;
                 }
 
-                //MOV EAX callback - 1 + sizeof(SWT_PTR) bytes
+                //MOV EAX callback - 1 + SWT_PTR.sizeof bytes
                 code[j++] = 0xb8;
                 (cast(SWT_PTR*) &code[j])[0] = cast(SWT_PTR) &callback;
-                j += sizeof(SWT_PTR);
+                j += SWT_PTR.sizeof;
 
                 //CALL EAX - 2 bytes
                 code[j++] = 0xff;
                 code[j++] = 0xd0;
 
-                //ADD ESP,(argCount + 1) * sizeof(SWT_PTR) - 3 bytes
+                //ADD ESP,(argCount + 1) * SWT_PTR.sizeof - 3 bytes
                 code[j++] = 0x83;
                 code[j++] = 0xc4;
 
                 version (darwin)
-                    code[j++] = cast(ubyte) (pad + ((argCount + 1) * sizeof(
-                            SWT_PTR)));
+                    code[j++] = cast(ubyte) (pad + ((argCount + 1) * SWT_PTR.sizeof));
                 else
-                    code[j++] = cast(ubyte) ((argCount + 1) * sizeof(SWT_PTR));
+                    code[j++] = cast(ubyte) ((argCount + 1) * SWT_PTR.sizeof);
 
                 //POP EBP - 1 byte
                 code[j++] = 0x5d;
 
                 version (Win32)
                 {
-                    // RETN argCount * sizeof(SWT_PTR) - 3 bytes
+                    // RETN argCount * SWT_PTR.sizeof - 3 bytes
                     code[j++] = 0xc2;
-                    code[j++] = cast(ubyte) (argCount * sizeof(SWT_PTR));
+                    code[j++] = cast(ubyte) (argCount * SWT_PTR.sizeof);
                     code[j++] = 0x00;
                 }
 
                 else version (Win32_WCE)
                 {
-                    // RETN argCount * sizeof(SWT_PTR) - 3 bytes
+                    // RETN argCount * SWT_PTR.sizeof - 3 bytes
                     code[j++] = 0xc2;
-                    code[j++] = cast(ubyte) (argCount * sizeof(SWT_PTR));
+                    code[j++] = cast(ubyte) (argCount * SWT_PTR.sizeof);
                     code[j++] = 0x00;
                 }
 
@@ -254,9 +261,7 @@
 
                 if (j > CALLBACK_THUNK_SIZE)
                 {
-                    jclass
-                            errorClass = (*env).FindClass(env,
-                                    "java/lang/Error");
+                    jclass errorClass = (*env).FindClass(env, "java/lang/Error");
                     (*env).ThrowNew(env, errorClass, "Callback thunk overflow");
                 }
 
@@ -266,5 +271,5 @@
     }
     
     fail:
-    return 0;
+        return 0;
 }