embedding

18 files changed, 1013 insertions, 43 deletions

diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os.c b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os.c
index 6652b20b58..2ba9df3255 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os.c
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os.c
@@ -846,6 +846,33 @@ JNIEXPORT jboolean JNICALL OS_NATIVE(XGetWindowAttributes)
 }
 #endif
 
+#ifndef NO_XGetWindowProperty
+JNIEXPORT jint JNICALL OS_NATIVE(XGetWindowProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jboolean arg5, jint arg6, jintArray arg7, jintArray arg8, jintArray arg9, jintArray arg10, jintArray arg11)
+{
+	jint *lparg7=NULL;
+	jint *lparg8=NULL;
+	jint *lparg9=NULL;
+	jint *lparg10=NULL;
+	jint *lparg11=NULL;
+	jint rc;
+	NATIVE_ENTER(env, that, "XGetWindowProperty\n")
+	if (arg7) lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL);
+	if (arg8) lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL);
+	if (arg9) lparg9 = (*env)->GetIntArrayElements(env, arg9, NULL);
+	if (arg10) lparg10 = (*env)->GetIntArrayElements(env, arg10, NULL);
+	if (arg11) lparg11 = (*env)->GetIntArrayElements(env, arg11, NULL);
+	rc = (jint)XGetWindowProperty((Display *)arg0, (Window)arg1, (Atom)arg2, arg3, arg4, (Bool)arg5, (Atom)arg6, (Atom *)lparg7, (int *)lparg8, (unsigned long *)lparg9, (unsigned long *)lparg10, (unsigned char **)lparg11);
+	if (arg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);
+	if (arg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0);
+	if (arg9) (*env)->ReleaseIntArrayElements(env, arg9, lparg9, 0);
+	if (arg10) (*env)->ReleaseIntArrayElements(env, arg10, lparg10, 0);
+	if (arg11) (*env)->ReleaseIntArrayElements(env, arg11, lparg11, 0);
+	NATIVE_EXIT(env, that, "XGetWindowProperty\n")
+	return rc;
+}
+#endif
+
 #ifndef NO_XGrabKeyboard
 JNIEXPORT jint JNICALL OS_NATIVE(XGrabKeyboard)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
@@ -990,6 +1017,26 @@ JNIEXPORT jint JNICALL OS_NATIVE(XLowerWindow)
 }
 #endif
 
+#ifndef NO_XMapWindow
+JNIEXPORT void JNICALL OS_NATIVE(XMapWindow)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	NATIVE_ENTER(env, that, "XMapWindow\n")
+	XMapWindow((Display *)arg0, (Window)arg1);
+	NATIVE_EXIT(env, that, "XMapWindow\n")
+}
+#endif
+
+#ifndef NO_XMoveResizeWindow
+JNIEXPORT void JNICALL OS_NATIVE(XMoveResizeWindow)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
+{
+	NATIVE_ENTER(env, that, "XMoveResizeWindow\n")
+	XMoveResizeWindow((Display *)arg0, (Window)arg1, arg2, arg3, arg4, arg5);
+	NATIVE_EXIT(env, that, "XMoveResizeWindow\n")
+}
+#endif
+
 #ifndef NO_XOpenDisplay
 JNIEXPORT jint JNICALL OS_NATIVE(XOpenDisplay)
 	(JNIEnv *env, jclass that, jbyteArray arg0)
@@ -1164,6 +1211,28 @@ JNIEXPORT jint JNICALL OS_NATIVE(XRootWindowOfScreen)
 }
 #endif
 
+#ifndef NO_XSelectInput
+JNIEXPORT void JNICALL OS_NATIVE(XSelectInput)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	NATIVE_ENTER(env, that, "XSelectInput\n")
+	XSelectInput((Display *)arg0, (Window)arg1, arg2);
+	NATIVE_EXIT(env, that, "XSelectInput\n")
+}
+#endif
+
+#ifndef NO_XSendEvent
+JNIEXPORT jint JNICALL OS_NATIVE(XSendEvent)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3, jint arg4)
+{
+	jint rc;
+	NATIVE_ENTER(env, that, "XSendEvent\n")
+	rc = (jint)XSendEvent((Display *)arg0, (Window)arg1, (Bool)arg2, (long)arg3, (XEvent *)arg4);
+	NATIVE_EXIT(env, that, "XSendEvent\n")
+	return rc;
+}
+#endif
+
 #ifndef NO_XSetBackground
 JNIEXPORT void JNICALL OS_NATIVE(XSetBackground)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
@@ -1419,6 +1488,16 @@ JNIEXPORT void JNICALL OS_NATIVE(XUnionRegion)
 }
 #endif
 
+#ifndef NO_XUnmapWindow
+JNIEXPORT void JNICALL OS_NATIVE(XUnmapWindow)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	NATIVE_ENTER(env, that, "XUnmapWindow\n")
+	XUnmapWindow((Display *)arg0, (Window)arg1);
+	NATIVE_EXIT(env, that, "XUnmapWindow\n")
+}
+#endif
+
 #ifndef NO_XWarpPointer
 JNIEXPORT jint JNICALL OS_NATIVE(XWarpPointer)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8)
@@ -4292,6 +4371,26 @@ JNIEXPORT void JNICALL OS_NATIVE(XtRealizeWidget)
 }
 #endif
 
+#ifndef NO_XtRegisterDrawable
+JNIEXPORT void JNICALL OS_NATIVE(XtRegisterDrawable)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	NATIVE_ENTER(env, that, "XtRegisterDrawable\n")
+	XtRegisterDrawable((Display *)arg0, (Drawable)arg1, (Widget)arg2);
+	NATIVE_EXIT(env, that, "XtRegisterDrawable\n")
+}
+#endif
+
+#ifndef NO_XtRemoveEventHandler
+JNIEXPORT void JNICALL OS_NATIVE(XtRemoveEventHandler)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3, jint arg4)
+{
+	NATIVE_ENTER(env, that, "XtRemoveEventHandler\n")
+	XtRemoveEventHandler((Widget)arg0, arg1, arg2, (XtEventHandler)arg3, (XtPointer)arg4);
+	NATIVE_EXIT(env, that, "XtRemoveEventHandler\n")
+}
+#endif
+
 #ifndef NO_XtRemoveInput
 JNIEXPORT void JNICALL OS_NATIVE(XtRemoveInput)
 	(JNIEnv *env, jclass that, jint arg0)
@@ -4425,6 +4524,16 @@ JNIEXPORT void JNICALL OS_NATIVE(XtUnmapWidget)
 }
 #endif
 
+#ifndef NO_XtUnregisterDrawable
+JNIEXPORT void JNICALL OS_NATIVE(XtUnregisterDrawable)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	NATIVE_ENTER(env, that, "XtUnregisterDrawable\n")
+	XtUnregisterDrawable((Display *)arg0, (Drawable)arg1);
+	NATIVE_EXIT(env, that, "XtUnregisterDrawable\n")
+}
+#endif
+
 #ifndef NO_XtWindow
 JNIEXPORT jint JNICALL OS_NATIVE(XtWindow)
 	(JNIEnv *env, jclass that, jint arg0)
@@ -4552,6 +4661,32 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XButt
 }
 #endif
 
+#ifndef NO_memmove__ILorg_eclipse_swt_internal_motif_XClientMessageEvent_2I
+JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XClientMessageEvent_2I)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
+{
+	XClientMessageEvent _arg1, *lparg1=NULL;
+	NATIVE_ENTER(env, that, "memmove__ILorg_eclipse_swt_internal_motif_XClientMessageEvent_2I\n")
+	if (arg1) lparg1 = getXClientMessageEventFields(env, arg1, &_arg1);
+	memmove((void *)arg0, (const void *)lparg1, (size_t)arg2);
+	if (arg1) setXClientMessageEventFields(env, arg1, lparg1);
+	NATIVE_EXIT(env, that, "memmove__ILorg_eclipse_swt_internal_motif_XClientMessageEvent_2I\n")
+}
+#endif
+
+#ifndef NO_memmove__ILorg_eclipse_swt_internal_motif_XConfigureEvent_2I
+JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XConfigureEvent_2I)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
+{
+	XConfigureEvent _arg1, *lparg1=NULL;
+	NATIVE_ENTER(env, that, "memmove__ILorg_eclipse_swt_internal_motif_XConfigureEvent_2I\n")
+	if (arg1) lparg1 = getXConfigureEventFields(env, arg1, &_arg1);
+	memmove((void *)arg0, (const void *)lparg1, (size_t)arg2);
+	if (arg1) setXConfigureEventFields(env, arg1, lparg1);
+	NATIVE_EXIT(env, that, "memmove__ILorg_eclipse_swt_internal_motif_XConfigureEvent_2I\n")
+}
+#endif
+
 #ifndef NO_memmove__ILorg_eclipse_swt_internal_motif_XExposeEvent_2I
 JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XExposeEvent_2I)
 	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
@@ -4576,6 +4711,19 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XImag
 }
 #endif
 
+#ifndef NO_memmove__ILorg_eclipse_swt_internal_motif_XKeyEvent_2I
+JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XKeyEvent_2I)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
+{
+	XKeyEvent _arg1, *lparg1=NULL;
+	NATIVE_ENTER(env, that, "memmove__ILorg_eclipse_swt_internal_motif_XKeyEvent_2I\n")
+	if (arg1) lparg1 = getXKeyEventFields(env, arg1, &_arg1);
+	memmove((void *)arg0, (const void *)lparg1, (size_t)arg2);
+	if (arg1) setXKeyEventFields(env, arg1, lparg1);
+	NATIVE_EXIT(env, that, "memmove__ILorg_eclipse_swt_internal_motif_XKeyEvent_2I\n")
+}
+#endif
+
 #ifndef NO_memmove__ILorg_eclipse_swt_internal_motif_XmDragProcCallbackStruct_2I
 JNIEXPORT void JNICALL OS_NATIVE(memmove__ILorg_eclipse_swt_internal_motif_XmDragProcCallbackStruct_2I)
 	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
@@ -4677,19 +4825,6 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_Visual
 }
 #endif
 
-#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XAnyEvent_2II
-JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XAnyEvent_2II)
-	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
-{
-	XAnyEvent _arg0, *lparg0=NULL;
-	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XAnyEvent_2II\n")
-	if (arg0) lparg0 = &_arg0;
-	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
-	if (arg0) setXAnyEventFields(env, arg0, lparg0);
-	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XAnyEvent_2II\n")
-}
-#endif
-
 #ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XButtonEvent_2II
 JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XButtonEvent_2II)
 	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
@@ -4716,6 +4851,19 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XCharS
 }
 #endif
 
+#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XClientMessageEvent_2II
+JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XClientMessageEvent_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XClientMessageEvent _arg0, *lparg0=NULL;
+	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XClientMessageEvent_2II\n")
+	if (arg0) lparg0 = getXClientMessageEventFields(env, arg0, &_arg0);
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXClientMessageEventFields(env, arg0, lparg0);
+	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XClientMessageEvent_2II\n")
+}
+#endif
+
 #ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XConfigureEvent_2II
 JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XConfigureEvent_2II)
 	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
@@ -4729,6 +4877,19 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XConfi
 }
 #endif
 
+#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XCreateWindowEvent_2II
+JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XCreateWindowEvent_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XCreateWindowEvent _arg0, *lparg0=NULL;
+	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XCreateWindowEvent_2II\n")
+	if (arg0) lparg0 = getXCreateWindowEventFields(env, arg0, &_arg0);
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXCreateWindowEventFields(env, arg0, lparg0);
+	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XCreateWindowEvent_2II\n")
+}
+#endif
+
 #ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XCrossingEvent_2II
 JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XCrossingEvent_2II)
 	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
@@ -4742,6 +4903,32 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XCross
 }
 #endif
 
+#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XDestroyWindowEvent_2II
+JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XDestroyWindowEvent_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XDestroyWindowEvent _arg0, *lparg0=NULL;
+	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XDestroyWindowEvent_2II\n")
+	if (arg0) lparg0 = getXDestroyWindowEventFields(env, arg0, &_arg0);
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXDestroyWindowEventFields(env, arg0, lparg0);
+	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XDestroyWindowEvent_2II\n")
+}
+#endif
+
+#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XEvent_2II
+JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XEvent_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XEvent _arg0, *lparg0=NULL;
+	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XEvent_2II\n")
+	if (arg0) lparg0 = getXEventFields(env, arg0, &_arg0);
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXEventFields(env, arg0, lparg0);
+	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XEvent_2II\n")
+}
+#endif
+
 #ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XExposeEvent_2II
 JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XExposeEvent_2II)
 	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
@@ -4820,6 +5007,32 @@ JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XMotio
 }
 #endif
 
+#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XPropertyEvent_2II
+JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XPropertyEvent_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XPropertyEvent _arg0, *lparg0=NULL;
+	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XPropertyEvent_2II\n")
+	if (arg0) lparg0 = getXPropertyEventFields(env, arg0, &_arg0);
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXPropertyEventFields(env, arg0, lparg0);
+	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XPropertyEvent_2II\n")
+}
+#endif
+
+#ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XReparentEvent_2II
+JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XReparentEvent_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XReparentEvent _arg0, *lparg0=NULL;
+	NATIVE_ENTER(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XReparentEvent_2II\n")
+	if (arg0) lparg0 = getXReparentEventFields(env, arg0, &_arg0);
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXReparentEventFields(env, arg0, lparg0);
+	NATIVE_EXIT(env, that, "memmove__Lorg_eclipse_swt_internal_motif_XReparentEvent_2II\n")
+}
+#endif
+
 #ifndef NO_memmove__Lorg_eclipse_swt_internal_motif_XineramaScreenInfo_2II
 JNIEXPORT void JNICALL OS_NATIVE(memmove__Lorg_eclipse_swt_internal_motif_XineramaScreenInfo_2II)
 	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.c b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.c
index 5579c071bc..ec479d6a56 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.c
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.c
@@ -245,6 +245,52 @@ void setXCharStructFields(JNIEnv *env, jobject lpObject, XCharStruct *lpStruct)
 }
 #endif
 
+#ifndef NO_XClientMessageEvent
+typedef struct XClientMessageEvent_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID message_type, format, data;
+} XClientMessageEvent_FID_CACHE;
+
+XClientMessageEvent_FID_CACHE XClientMessageEventFc;
+
+void cacheXClientMessageEventFields(JNIEnv *env, jobject lpObject)
+{
+	if (XClientMessageEventFc.cached) return;
+	cacheXAnyEventFields(env, lpObject);
+	XClientMessageEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
+	XClientMessageEventFc.message_type = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "message_type", "I");
+	XClientMessageEventFc.format = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "format", "I");
+	XClientMessageEventFc.data = (*env)->GetFieldID(env, XClientMessageEventFc.clazz, "data", "[I");
+	XClientMessageEventFc.cached = 1;
+}
+
+XClientMessageEvent *getXClientMessageEventFields(JNIEnv *env, jobject lpObject, XClientMessageEvent *lpStruct)
+{
+	if (!XClientMessageEventFc.cached) cacheXClientMessageEventFields(env, lpObject);
+	getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct);
+	lpStruct->message_type = (Atom)(*env)->GetIntField(env, lpObject, XClientMessageEventFc.message_type);
+	lpStruct->format = (*env)->GetIntField(env, lpObject, XClientMessageEventFc.format);
+	{
+	jintArray lpObject1 = (*env)->GetObjectField(env, lpObject, XClientMessageEventFc.data);
+	(*env)->GetIntArrayRegion(env, lpObject1, 0, sizeof(lpStruct->data.l) / 4, (void *)lpStruct->data.l);
+	}
+	return lpStruct;
+}
+
+void setXClientMessageEventFields(JNIEnv *env, jobject lpObject, XClientMessageEvent *lpStruct)
+{
+	if (!XClientMessageEventFc.cached) cacheXClientMessageEventFields(env, lpObject);
+	setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct);
+	(*env)->SetIntField(env, lpObject, XClientMessageEventFc.message_type, (jint)lpStruct->message_type);
+	(*env)->SetIntField(env, lpObject, XClientMessageEventFc.format, (jint)lpStruct->format);
+	{
+	jintArray lpObject1 = (*env)->GetObjectField(env, lpObject, XClientMessageEventFc.data);
+	(*env)->SetIntArrayRegion(env, lpObject1, 0, sizeof(lpStruct->data.l) / 4, (void *)lpStruct->data.l);
+	}
+}
+#endif
+
 #ifndef NO_XColor
 typedef struct XColor_FID_CACHE {
 	int cached;
@@ -295,7 +341,7 @@ void setXColorFields(JNIEnv *env, jobject lpObject, XColor *lpStruct)
 typedef struct XConfigureEvent_FID_CACHE {
 	int cached;
 	jclass clazz;
-	jfieldID x, y, width, height, border_width, above, override_redirect;
+	jfieldID serial, send_event, display, event, window, x, y, width, height, border_width, above, override_redirect;
 } XConfigureEvent_FID_CACHE;
 
 XConfigureEvent_FID_CACHE XConfigureEventFc;
@@ -303,8 +349,13 @@ XConfigureEvent_FID_CACHE XConfigureEventFc;
 void cacheXConfigureEventFields(JNIEnv *env, jobject lpObject)
 {
 	if (XConfigureEventFc.cached) return;
-	cacheXAnyEventFields(env, lpObject);
+	cacheXEventFields(env, lpObject);
 	XConfigureEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
+	XConfigureEventFc.serial = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "serial", "I");
+	XConfigureEventFc.send_event = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "send_event", "I");
+	XConfigureEventFc.display = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "display", "I");
+	XConfigureEventFc.event = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "event", "I");
+	XConfigureEventFc.window = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "window", "I");
 	XConfigureEventFc.x = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "x", "I");
 	XConfigureEventFc.y = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "y", "I");
 	XConfigureEventFc.width = (*env)->GetFieldID(env, XConfigureEventFc.clazz, "width", "I");
@@ -318,13 +369,18 @@ void cacheXConfigureEventFields(JNIEnv *env, jobject lpObject)
 XConfigureEvent *getXConfigureEventFields(JNIEnv *env, jobject lpObject, XConfigureEvent *lpStruct)
 {
 	if (!XConfigureEventFc.cached) cacheXConfigureEventFields(env, lpObject);
-	getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct);
+	getXEventFields(env, lpObject, (XEvent *)lpStruct);
+	lpStruct->serial = (*env)->GetIntField(env, lpObject, XConfigureEventFc.serial);
+	lpStruct->send_event = (*env)->GetIntField(env, lpObject, XConfigureEventFc.send_event);
+	lpStruct->display = (Display *)(*env)->GetIntField(env, lpObject, XConfigureEventFc.display);
+	lpStruct->event = (Window)(*env)->GetIntField(env, lpObject, XConfigureEventFc.event);
+	lpStruct->window = (Window)(*env)->GetIntField(env, lpObject, XConfigureEventFc.window);
 	lpStruct->x = (*env)->GetIntField(env, lpObject, XConfigureEventFc.x);
 	lpStruct->y = (*env)->GetIntField(env, lpObject, XConfigureEventFc.y);
 	lpStruct->width = (*env)->GetIntField(env, lpObject, XConfigureEventFc.width);
 	lpStruct->height = (*env)->GetIntField(env, lpObject, XConfigureEventFc.height);
 	lpStruct->border_width = (*env)->GetIntField(env, lpObject, XConfigureEventFc.border_width);
-	lpStruct->above = (*env)->GetIntField(env, lpObject, XConfigureEventFc.above);
+	lpStruct->above = (Window)(*env)->GetIntField(env, lpObject, XConfigureEventFc.above);
 	lpStruct->override_redirect = (*env)->GetIntField(env, lpObject, XConfigureEventFc.override_redirect);
 	return lpStruct;
 }
@@ -332,7 +388,12 @@ XConfigureEvent *getXConfigureEventFields(JNIEnv *env, jobject lpObject, XConfig
 void setXConfigureEventFields(JNIEnv *env, jobject lpObject, XConfigureEvent *lpStruct)
 {
 	if (!XConfigureEventFc.cached) cacheXConfigureEventFields(env, lpObject);
-	setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct);
+	setXEventFields(env, lpObject, (XEvent *)lpStruct);
+	(*env)->SetIntField(env, lpObject, XConfigureEventFc.serial, (jint)lpStruct->serial);
+	(*env)->SetIntField(env, lpObject, XConfigureEventFc.send_event, (jint)lpStruct->send_event);
+	(*env)->SetIntField(env, lpObject, XConfigureEventFc.display, (jint)lpStruct->display);
+	(*env)->SetIntField(env, lpObject, XConfigureEventFc.event, (jint)lpStruct->event);
+	(*env)->SetIntField(env, lpObject, XConfigureEventFc.window, (jint)lpStruct->window);
 	(*env)->SetIntField(env, lpObject, XConfigureEventFc.x, (jint)lpStruct->x);
 	(*env)->SetIntField(env, lpObject, XConfigureEventFc.y, (jint)lpStruct->y);
 	(*env)->SetIntField(env, lpObject, XConfigureEventFc.width, (jint)lpStruct->width);
@@ -343,6 +404,70 @@ void setXConfigureEventFields(JNIEnv *env, jobject lpObject, XConfigureEvent *lp
 }
 #endif
 
+#ifndef NO_XCreateWindowEvent
+typedef struct XCreateWindowEvent_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID serial, send_event, display, parent, window, x, y, width, height, border_width, override_redirect;
+} XCreateWindowEvent_FID_CACHE;
+
+XCreateWindowEvent_FID_CACHE XCreateWindowEventFc;
+
+void cacheXCreateWindowEventFields(JNIEnv *env, jobject lpObject)
+{
+	if (XCreateWindowEventFc.cached) return;
+	cacheXEventFields(env, lpObject);
+	XCreateWindowEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
+	XCreateWindowEventFc.serial = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "serial", "I");
+	XCreateWindowEventFc.send_event = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "send_event", "I");
+	XCreateWindowEventFc.display = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "display", "I");
+	XCreateWindowEventFc.parent = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "parent", "I");
+	XCreateWindowEventFc.window = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "window", "I");
+	XCreateWindowEventFc.x = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "x", "I");
+	XCreateWindowEventFc.y = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "y", "I");
+	XCreateWindowEventFc.width = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "width", "I");
+	XCreateWindowEventFc.height = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "height", "I");
+	XCreateWindowEventFc.border_width = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "border_width", "I");
+	XCreateWindowEventFc.override_redirect = (*env)->GetFieldID(env, XCreateWindowEventFc.clazz, "override_redirect", "I");
+	XCreateWindowEventFc.cached = 1;
+}
+
+XCreateWindowEvent *getXCreateWindowEventFields(JNIEnv *env, jobject lpObject, XCreateWindowEvent *lpStruct)
+{
+	if (!XCreateWindowEventFc.cached) cacheXCreateWindowEventFields(env, lpObject);
+	getXEventFields(env, lpObject, (XEvent *)lpStruct);
+	lpStruct->serial = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.serial);
+	lpStruct->send_event = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.send_event);
+	lpStruct->display = (Display *)(*env)->GetIntField(env, lpObject, XCreateWindowEventFc.display);
+	lpStruct->parent = (Window)(*env)->GetIntField(env, lpObject, XCreateWindowEventFc.parent);
+	lpStruct->window = (Window)(*env)->GetIntField(env, lpObject, XCreateWindowEventFc.window);
+	lpStruct->x = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.x);
+	lpStruct->y = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.y);
+	lpStruct->width = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.width);
+	lpStruct->height = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.height);
+	lpStruct->border_width = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.border_width);
+	lpStruct->override_redirect = (*env)->GetIntField(env, lpObject, XCreateWindowEventFc.override_redirect);
+	return lpStruct;
+}
+
+void setXCreateWindowEventFields(JNIEnv *env, jobject lpObject, XCreateWindowEvent *lpStruct)
+{
+	if (!XCreateWindowEventFc.cached) cacheXCreateWindowEventFields(env, lpObject);
+	setXEventFields(env, lpObject, (XEvent *)lpStruct);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.serial, (jint)lpStruct->serial);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.send_event, (jint)lpStruct->send_event);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.display, (jint)lpStruct->display);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.parent, (jint)lpStruct->parent);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.window, (jint)lpStruct->window);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.x, (jint)lpStruct->x);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.y, (jint)lpStruct->y);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.width, (jint)lpStruct->width);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.height, (jint)lpStruct->height);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.border_width, (jint)lpStruct->border_width);
+	(*env)->SetIntField(env, lpObject, XCreateWindowEventFc.override_redirect, (jint)lpStruct->override_redirect);
+}
+#endif
+
 #ifndef NO_XCrossingEvent
 typedef struct XCrossingEvent_FID_CACHE {
 	int cached;
@@ -410,6 +535,52 @@ void setXCrossingEventFields(JNIEnv *env, jobject lpObject, XCrossingEvent *lpSt
 }
 #endif
 
+#ifndef NO_XDestroyWindowEvent
+typedef struct XDestroyWindowEvent_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID serial, send_event, display, event, window;
+} XDestroyWindowEvent_FID_CACHE;
+
+XDestroyWindowEvent_FID_CACHE XDestroyWindowEventFc;
+
+void cacheXDestroyWindowEventFields(JNIEnv *env, jobject lpObject)
+{
+	if (XDestroyWindowEventFc.cached) return;
+	cacheXEventFields(env, lpObject);
+	XDestroyWindowEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
+	XDestroyWindowEventFc.serial = (*env)->GetFieldID(env, XDestroyWindowEventFc.clazz, "serial", "I");
+	XDestroyWindowEventFc.send_event = (*env)->GetFieldID(env, XDestroyWindowEventFc.clazz, "send_event", "I");
+	XDestroyWindowEventFc.display = (*env)->GetFieldID(env, XDestroyWindowEventFc.clazz, "display", "I");
+	XDestroyWindowEventFc.event = (*env)->GetFieldID(env, XDestroyWindowEventFc.clazz, "event", "I");
+	XDestroyWindowEventFc.window = (*env)->GetFieldID(env, XDestroyWindowEventFc.clazz, "window", "I");
+	XDestroyWindowEventFc.cached = 1;
+}
+
+XDestroyWindowEvent *getXDestroyWindowEventFields(JNIEnv *env, jobject lpObject, XDestroyWindowEvent *lpStruct)
+{
+	if (!XDestroyWindowEventFc.cached) cacheXDestroyWindowEventFields(env, lpObject);
+	getXEventFields(env, lpObject, (XEvent *)lpStruct);
+	lpStruct->serial = (*env)->GetIntField(env, lpObject, XDestroyWindowEventFc.serial);
+	lpStruct->send_event = (*env)->GetIntField(env, lpObject, XDestroyWindowEventFc.send_event);
+	lpStruct->display = (Display *)(*env)->GetIntField(env, lpObject, XDestroyWindowEventFc.display);
+	lpStruct->event = (Window)(*env)->GetIntField(env, lpObject, XDestroyWindowEventFc.event);
+	lpStruct->window = (Window)(*env)->GetIntField(env, lpObject, XDestroyWindowEventFc.window);
+	return lpStruct;
+}
+
+void setXDestroyWindowEventFields(JNIEnv *env, jobject lpObject, XDestroyWindowEvent *lpStruct)
+{
+	if (!XDestroyWindowEventFc.cached) cacheXDestroyWindowEventFields(env, lpObject);
+	setXEventFields(env, lpObject, (XEvent *)lpStruct);
+	(*env)->SetIntField(env, lpObject, XDestroyWindowEventFc.serial, (jint)lpStruct->serial);
+	(*env)->SetIntField(env, lpObject, XDestroyWindowEventFc.send_event, (jint)lpStruct->send_event);
+	(*env)->SetIntField(env, lpObject, XDestroyWindowEventFc.display, (jint)lpStruct->display);
+	(*env)->SetIntField(env, lpObject, XDestroyWindowEventFc.event, (jint)lpStruct->event);
+	(*env)->SetIntField(env, lpObject, XDestroyWindowEventFc.window, (jint)lpStruct->window);
+}
+#endif
+
 #ifndef NO_XExposeEvent
 typedef struct XExposeEvent_FID_CACHE {
 	int cached;
@@ -912,6 +1083,46 @@ void setXMotionEventFields(JNIEnv *env, jobject lpObject, XMotionEvent *lpStruct
 }
 #endif
 
+#ifndef NO_XPropertyEvent
+typedef struct XPropertyEvent_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID atom, time, state;
+} XPropertyEvent_FID_CACHE;
+
+XPropertyEvent_FID_CACHE XPropertyEventFc;
+
+void cacheXPropertyEventFields(JNIEnv *env, jobject lpObject)
+{
+	if (XPropertyEventFc.cached) return;
+	cacheXAnyEventFields(env, lpObject);
+	XPropertyEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
+	XPropertyEventFc.atom = (*env)->GetFieldID(env, XPropertyEventFc.clazz, "atom", "I");
+	XPropertyEventFc.time = (*env)->GetFieldID(env, XPropertyEventFc.clazz, "time", "I");
+	XPropertyEventFc.state = (*env)->GetFieldID(env, XPropertyEventFc.clazz, "state", "I");
+	XPropertyEventFc.cached = 1;
+}
+
+XPropertyEvent *getXPropertyEventFields(JNIEnv *env, jobject lpObject, XPropertyEvent *lpStruct)
+{
+	if (!XPropertyEventFc.cached) cacheXPropertyEventFields(env, lpObject);
+	getXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct);
+	lpStruct->atom = (*env)->GetIntField(env, lpObject, XPropertyEventFc.atom);
+	lpStruct->time = (*env)->GetIntField(env, lpObject, XPropertyEventFc.time);
+	lpStruct->state = (*env)->GetIntField(env, lpObject, XPropertyEventFc.state);
+	return lpStruct;
+}
+
+void setXPropertyEventFields(JNIEnv *env, jobject lpObject, XPropertyEvent *lpStruct)
+{
+	if (!XPropertyEventFc.cached) cacheXPropertyEventFields(env, lpObject);
+	setXAnyEventFields(env, lpObject, (XAnyEvent *)lpStruct);
+	(*env)->SetIntField(env, lpObject, XPropertyEventFc.atom, (jint)lpStruct->atom);
+	(*env)->SetIntField(env, lpObject, XPropertyEventFc.time, (jint)lpStruct->time);
+	(*env)->SetIntField(env, lpObject, XPropertyEventFc.state, (jint)lpStruct->state);
+}
+#endif
+
 #ifndef NO_XRectangle
 typedef struct XRectangle_FID_CACHE {
 	int cached;
@@ -952,6 +1163,64 @@ void setXRectangleFields(JNIEnv *env, jobject lpObject, XRectangle *lpStruct)
 }
 #endif
 
+#ifndef NO_XReparentEvent
+typedef struct XReparentEvent_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID serial, send_event, display, event, window, parent, x, y, override_redirect;
+} XReparentEvent_FID_CACHE;
+
+XReparentEvent_FID_CACHE XReparentEventFc;
+
+void cacheXReparentEventFields(JNIEnv *env, jobject lpObject)
+{
+	if (XReparentEventFc.cached) return;
+	cacheXEventFields(env, lpObject);
+	XReparentEventFc.clazz = (*env)->GetObjectClass(env, lpObject);
+	XReparentEventFc.serial = (*env)->GetFieldID(env, XReparentEventFc.clazz, "serial", "I");
+	XReparentEventFc.send_event = (*env)->GetFieldID(env, XReparentEventFc.clazz, "send_event", "I");
+	XReparentEventFc.display = (*env)->GetFieldID(env, XReparentEventFc.clazz, "display", "I");
+	XReparentEventFc.event = (*env)->GetFieldID(env, XReparentEventFc.clazz, "event", "I");
+	XReparentEventFc.window = (*env)->GetFieldID(env, XReparentEventFc.clazz, "window", "I");
+	XReparentEventFc.parent = (*env)->GetFieldID(env, XReparentEventFc.clazz, "parent", "I");
+	XReparentEventFc.x = (*env)->GetFieldID(env, XReparentEventFc.clazz, "x", "I");
+	XReparentEventFc.y = (*env)->GetFieldID(env, XReparentEventFc.clazz, "y", "I");
+	XReparentEventFc.override_redirect = (*env)->GetFieldID(env, XReparentEventFc.clazz, "override_redirect", "I");
+	XReparentEventFc.cached = 1;
+}
+
+XReparentEvent *getXReparentEventFields(JNIEnv *env, jobject lpObject, XReparentEvent *lpStruct)
+{
+	if (!XReparentEventFc.cached) cacheXReparentEventFields(env, lpObject);
+	getXEventFields(env, lpObject, (XEvent *)lpStruct);
+	lpStruct->serial = (*env)->GetIntField(env, lpObject, XReparentEventFc.serial);
+	lpStruct->send_event = (*env)->GetIntField(env, lpObject, XReparentEventFc.send_event);
+	lpStruct->display = (Display *)(*env)->GetIntField(env, lpObject, XReparentEventFc.display);
+	lpStruct->event = (Window)(*env)->GetIntField(env, lpObject, XReparentEventFc.event);
+	lpStruct->window = (Window)(*env)->GetIntField(env, lpObject, XReparentEventFc.window);
+	lpStruct->parent = (Window)(*env)->GetIntField(env, lpObject, XReparentEventFc.parent);
+	lpStruct->x = (*env)->GetIntField(env, lpObject, XReparentEventFc.x);
+	lpStruct->y = (*env)->GetIntField(env, lpObject, XReparentEventFc.y);
+	lpStruct->override_redirect = (*env)->GetIntField(env, lpObject, XReparentEventFc.override_redirect);
+	return lpStruct;
+}
+
+void setXReparentEventFields(JNIEnv *env, jobject lpObject, XReparentEvent *lpStruct)
+{
+	if (!XReparentEventFc.cached) cacheXReparentEventFields(env, lpObject);
+	setXEventFields(env, lpObject, (XEvent *)lpStruct);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.serial, (jint)lpStruct->serial);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.send_event, (jint)lpStruct->send_event);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.display, (jint)lpStruct->display);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.event, (jint)lpStruct->event);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.window, (jint)lpStruct->window);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.parent, (jint)lpStruct->parent);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.x, (jint)lpStruct->x);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.y, (jint)lpStruct->y);
+	(*env)->SetIntField(env, lpObject, XReparentEventFc.override_redirect, (jint)lpStruct->override_redirect);
+}
+#endif
+
 #ifndef NO_XSetWindowAttributes
 typedef struct XSetWindowAttributes_FID_CACHE {
 	int cached;
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.h b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.h
index d24f168f02..1aab3af6a4 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.h
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/library/os_structs.h
@@ -51,6 +51,14 @@ void setXCharStructFields(JNIEnv *env, jobject lpObject, XCharStruct *lpStruct);
 #define setXCharStructFields(a,b,c)
 #endif
 
+#ifndef NO_XClientMessageEvent
+XClientMessageEvent *getXClientMessageEventFields(JNIEnv *env, jobject lpObject, XClientMessageEvent *lpStruct);
+void setXClientMessageEventFields(JNIEnv *env, jobject lpObject, XClientMessageEvent *lpStruct);
+#else
+#define getXClientMessageEventFields(a,b,c) NULL
+#define setXClientMessageEventFields(a,b,c)
+#endif
+
 #ifndef NO_XColor
 XColor *getXColorFields(JNIEnv *env, jobject lpObject, XColor *lpStruct);
 void setXColorFields(JNIEnv *env, jobject lpObject, XColor *lpStruct);
@@ -67,6 +75,14 @@ void setXConfigureEventFields(JNIEnv *env, jobject lpObject, XConfigureEvent *lp
 #define setXConfigureEventFields(a,b,c)
 #endif
 
+#ifndef NO_XCreateWindowEvent
+XCreateWindowEvent *getXCreateWindowEventFields(JNIEnv *env, jobject lpObject, XCreateWindowEvent *lpStruct);
+void setXCreateWindowEventFields(JNIEnv *env, jobject lpObject, XCreateWindowEvent *lpStruct);
+#else
+#define getXCreateWindowEventFields(a,b,c) NULL
+#define setXCreateWindowEventFields(a,b,c)
+#endif
+
 #ifndef NO_XCrossingEvent
 XCrossingEvent *getXCrossingEventFields(JNIEnv *env, jobject lpObject, XCrossingEvent *lpStruct);
 void setXCrossingEventFields(JNIEnv *env, jobject lpObject, XCrossingEvent *lpStruct);
@@ -75,6 +91,14 @@ void setXCrossingEventFields(JNIEnv *env, jobject lpObject, XCrossingEvent *lpSt
 #define setXCrossingEventFields(a,b,c)
 #endif
 
+#ifndef NO_XDestroyWindowEvent
+XDestroyWindowEvent *getXDestroyWindowEventFields(JNIEnv *env, jobject lpObject, XDestroyWindowEvent *lpStruct);
+void setXDestroyWindowEventFields(JNIEnv *env, jobject lpObject, XDestroyWindowEvent *lpStruct);
+#else
+#define getXDestroyWindowEventFields(a,b,c) NULL
+#define setXDestroyWindowEventFields(a,b,c)
+#endif
+
 #ifndef NO_XExposeEvent
 XExposeEvent *getXExposeEventFields(JNIEnv *env, jobject lpObject, XExposeEvent *lpStruct);
 void setXExposeEventFields(JNIEnv *env, jobject lpObject, XExposeEvent *lpStruct);
@@ -131,6 +155,14 @@ void setXMotionEventFields(JNIEnv *env, jobject lpObject, XMotionEvent *lpStruct
 #define setXMotionEventFields(a,b,c)
 #endif
 
+#ifndef NO_XPropertyEvent
+XPropertyEvent *getXPropertyEventFields(JNIEnv *env, jobject lpObject, XPropertyEvent *lpStruct);
+void setXPropertyEventFields(JNIEnv *env, jobject lpObject, XPropertyEvent *lpStruct);
+#else
+#define getXPropertyEventFields(a,b,c) NULL
+#define setXPropertyEventFields(a,b,c)
+#endif
+
 #ifndef NO_XRectangle
 XRectangle *getXRectangleFields(JNIEnv *env, jobject lpObject, XRectangle *lpStruct);
 void setXRectangleFields(JNIEnv *env, jobject lpObject, XRectangle *lpStruct);
@@ -139,6 +171,14 @@ void setXRectangleFields(JNIEnv *env, jobject lpObject, XRectangle *lpStruct);
 #define setXRectangleFields(a,b,c)
 #endif
 
+#ifndef NO_XReparentEvent
+XReparentEvent *getXReparentEventFields(JNIEnv *env, jobject lpObject, XReparentEvent *lpStruct);
+void setXReparentEventFields(JNIEnv *env, jobject lpObject, XReparentEvent *lpStruct);
+#else
+#define getXReparentEventFields(a,b,c) NULL
+#define setXReparentEventFields(a,b,c)
+#endif
+
 #ifndef NO_XSetWindowAttributes
 XSetWindowAttributes *getXSetWindowAttributesFields(JNIEnv *env, jobject lpObject, XSetWindowAttributes *lpStruct);
 void setXSetWindowAttributesFields(JNIEnv *env, jobject lpObject, XSetWindowAttributes *lpStruct);
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/OS.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/OS.java
index 051fea6508..eda79fd609 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/OS.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/OS.java
@@ -67,12 +67,15 @@ public class OS {
 	public static final int CWStackMode = 0x40;
 	public static final int CWWidth = 0x4;
 	public static final int CapButt = 0x1;
+	public static final int ClientMessage = 33;
 	public static final int Complex = 0;
 	public static final int ConfigureNotify = 22;
 	public static final int ControlMask = (1<<2);
 	public static final int CoordModeOrigin = 0x0;
 	public static final int CopyFromParent = 0;
+	public static final int CreateNotify = 16;
 	public static final int CurrentTime = 0;
+	public static final int DestroyNotify = 17;
 	public static final int EnterNotify = 7;
 	public static final int EnterWindowMask = 1 << 4;
 	public static final int Expose = 12;
@@ -129,6 +132,8 @@ public class OS {
 	public static final int NotifyNonlinearVirtual = 0x4;
 	public static final int NotifyNormal = 0x0;
 	public static final int PointerMotionMask = 1 << 6;
+	public static final int PropertyChangeMask = 1 << 22;
+	public static final int PropertyNotify = 28;
 	public static final int QueuedAfterReading = 1;
 	public static final int RectangleOut = 0x0;
 	public static final int ReparentNotify = 21;
@@ -164,6 +169,23 @@ public class OS {
 	public static final int XC_watch = 150;
 	public static final int XC_xterm = 152;
 	public static final int XCompoundTextStyle = 1;
+	public static final int XEMBED_EMBEDDED_NOTIFY = 0;
+	public static final int XEMBED_WINDOW_ACTIVATE = 1;
+	public static final int XEMBED_WINDOW_DEACTIVATE = 2;
+	public static final int XEMBED_REQUEST_FOCUS = 3;
+	public static final int XEMBED_FOCUS_IN = 4;
+	public static final int XEMBED_FOCUS_OUT = 5;
+	public static final int XEMBED_FOCUS_NEXT = 6;
+	public static final int XEMBED_FOCUS_PREV = 7;
+	public static final int XEMBED_MODALITY_ON = 10;
+	public static final int XEMBED_MODALITY_OFF = 11;
+	public static final int XEMBED_REGISTER_ACCELERATOR = 12;
+	public static final int XEMBED_UNREGISTER_ACCELERATOR = 13;
+	public static final int XEMBED_ACTIVATE_ACCELERATOR = 14;
+	public static final int XEMBED_FOCUS_CURRENT = 0;
+	public static final int XEMBED_FOCUS_FIRST = 1;
+	public static final int XEMBED_FOCUS_LAST = 2;
+	public static final int XEMBED_MAPPED = 1 << 0;
 	public static final int XK_Alt_L = 0xFFE9;
 	public static final int XK_Alt_R = 0xFFEA;
 	public static final int XK_BackSpace = 0xFF08;
@@ -577,6 +599,7 @@ public static final synchronized native int XGetGeometry(int display, int drawab
 public static final synchronized native int XGetImage(int display, int drawable, int x, int y, int width, int height, int plane_mask, int format);
 public static final synchronized native int XGetInputFocus(int display, int[] window, int[] revert);
 public static final synchronized native boolean XGetWindowAttributes(int display, int window, XWindowAttributes attributes);
+public static final synchronized native int XGetWindowProperty(int display, int window, int property, int offset, int length, boolean delete, int req_type, int[] actual_type_return, int[] actual_format_return, int[] nitems_return, int[] bytes_after_return, int[] prop_return);
 public static final synchronized native int XGrabKeyboard(int display, int grabWindow, int ownerEvents, int pointerMode, int keyboardMode, int time);
 public static final synchronized native int XGrabPointer(int display, int grabWindow, int ownerEvents, int eventMask, int pointerMode, int keyboardMode, int confineToWindow, int cursor, int time);
 public static final synchronized native int XInitThreads();
@@ -587,6 +610,8 @@ public static final synchronized native int XListProperties(int display, int win
 public static final synchronized native int XLocaleOfFontSet(int fontSet);
 public static final synchronized native int XLookupString(XKeyEvent event, byte[] string, int size, int[] keysym, int[] status);
 public static final synchronized native int XLowerWindow(int display, int window);
+public static final synchronized native void XMapWindow(int display, int w);
+public static final synchronized native void XMoveResizeWindow(int display, int w, int x, int y, int width, int height);
 public static final synchronized native int XOpenDisplay(byte[] display_name);
 public static final synchronized native boolean XPointInRegion(int region, int x, int y);
 public static final synchronized native int XPutImage(int display, int drawable, int gc, int image, int srcX, int srcY, int destX, int destY, int width, int height);
@@ -598,6 +623,8 @@ public static final synchronized native int XReconfigureWMWindow(int display, in
 public static final synchronized native int XRectInRegion(int region, int x, int y, int width, int height);
 public static final synchronized native int XReparentWindow(int display, int win, int parent, int x, int y);
 public static final synchronized native int XRootWindowOfScreen(int screen);
+public static final synchronized native void XSelectInput(int display, int window, int mask);
+public static final synchronized native int XSendEvent(int display, int window, boolean propagate, int event_mask, int event);
 public static final synchronized native void XSetBackground(int display, int gc, int background);
 public static final synchronized native void XSetClipMask(int display, int gc, int pixmap);
 public static final synchronized native void XSetClipRectangles(int display, int gc, int clip_x_origin, int clip_y_origin, XRectangle rectangles, int n, int ordering);
@@ -621,6 +648,7 @@ public static final synchronized native int XUngrabKeyboard(int display, int tim
 public static final synchronized native int XUngrabPointer(int display, int time);
 public static final synchronized native void XUnionRectWithRegion(XRectangle rectangle, int src_region, int dest_region_return);
 public static final synchronized native void XUnionRegion(int sra, int srb, int dr_return);
+public static final synchronized native void XUnmapWindow(int display, int window);
 public static final synchronized native int XWarpPointer(int display, int sourceWindow, int destWindow, int sourceX, int sourceY, int sourceWidth, int sourceHeight, int destX, int destY);
 public static final synchronized native int XWhitePixel(int display, int screenNum);
 public static final synchronized native void XWithdrawWindow(int display, int window, int screen);
@@ -836,6 +864,8 @@ public static final synchronized native void XtPopdown(int widget);
 public static final synchronized native void XtPopup(int widget, int flags);
 public static final synchronized native int XtQueryGeometry(int widget, XtWidgetGeometry intended, XtWidgetGeometry preferred_return);
 public static final synchronized native void XtRealizeWidget(int widget);
+public static final synchronized native void XtRegisterDrawable(int display, int drawable, int widget);
+public static final synchronized native void XtRemoveEventHandler(int widget, int event_mask, boolean nonmaskable, int proc, int client_data);
 public static final synchronized native void XtRemoveInput(int id);
 public static final synchronized native void XtRemoveTimeOut(int id);
 public static final synchronized native void XtResizeWidget(int widget, int width, int height, int borderWidth);
@@ -848,6 +878,7 @@ public static final synchronized native boolean XtToolkitThreadInitialize();
 public static final synchronized native void XtTranslateCoords(int widget, short x, short y, short[] root_x, short[] root_y);
 public static final synchronized native void XtUnmanageChild(int widget);
 public static final synchronized native void XtUnmapWidget(int widget);
+public static final synchronized native void XtUnregisterDrawable(int display, int drawable);
 public static final synchronized native int XtWindow(int widget);
 public static final synchronized native int XtWindowToWidget(int display, int widget);
 public static final synchronized native void _XmSetMenuTraversal(int menu, boolean traversal);
@@ -868,16 +899,21 @@ public static final native void memmove(Visual dest, int src, int count);
 public static final native void memmove(XButtonEvent dest, int src, int count);
 public static final native void memmove(int dest, XButtonEvent src, int count);
 public static final native void memmove(XCharStruct dest, int src, int count);
+public static final native void memmove(XClientMessageEvent dest, int src, int count);
 public static final native void memmove(XConfigureEvent dest, int src, int count);
+public static final native void memmove(XCreateWindowEvent dest, int src, int count);
 public static final native void memmove(XCrossingEvent dest, int src, int count);
+public static final native void memmove(XDestroyWindowEvent dest, int src, int count);
 public static final native void memmove(XExposeEvent dest, int src, int count);
 public static final native void memmove(XFocusChangeEvent dest, int src, int count);
 public static final native void memmove(XFontStruct dest, int src, int count);
 public static final native void memmove(XImage dest, int src, int count);
 public static final native void memmove(XineramaScreenInfo dest, int src, int count);
 public static final native void memmove(XKeyEvent dest, int src, int count);
-public static final native void memmove(XAnyEvent dest, int src, int count);
+public static final native void memmove(XEvent dest, int src, int count);
 public static final native void memmove(XMotionEvent dest, int src, int count);
+public static final native void memmove(XPropertyEvent dest, int src, int count);
+public static final native void memmove(XReparentEvent dest, int src, int count);
 public static final native void memmove(XmAnyCallbackStruct dest, int src, int count);
 public static final native void memmove(XmDragProcCallbackStruct dest, int src, int count);
 public static final native void memmove(XmDropFinishCallbackStruct dest, int src, int count);
@@ -889,6 +925,9 @@ public static final native void memmove(char[] dest, int src, int count);
 public static final native void memmove(int[] dest, int src, int count);
 public static final native void memmove(int dest, short[] src, int count);
 public static final native void memmove(int dest, XExposeEvent src, int count);
+public static final native void memmove(int dest, XClientMessageEvent src, int count);
+public static final native void memmove(int dest, XConfigureEvent src, int count);
+public static final native void memmove(int dest, XKeyEvent src, int count);
 public static final native int nl_langinfo(int item);
 public static final native int pipe(int[] filedes);
 public static final native int read(int filedes, byte[] buf, int nbyte);
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XAnyEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XAnyEvent.java
index 6087130104..b88adf99ee 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XAnyEvent.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XAnyEvent.java
@@ -11,7 +11,7 @@
 package org.eclipse.swt.internal.motif;
 
  
-public class XAnyEvent extends XEvent {
+public abstract class XAnyEvent extends XEvent {
 	public int serial;
 	public int send_event;
 	public int display;
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XClientMessageEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XClientMessageEvent.java
new file mode 100644
index 0000000000..8c014d343a
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XClientMessageEvent.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.internal.motif;
+
+ 
+public class XClientMessageEvent extends XAnyEvent {
+	public int message_type;
+	public int format;
+	public int[] data = new int[5];
+	public static final int sizeof = 48;
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XConfigureEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XConfigureEvent.java
index 8827b44f39..6a5bb1b622 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XConfigureEvent.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XConfigureEvent.java
@@ -11,7 +11,12 @@
 package org.eclipse.swt.internal.motif;
 
  
-public class XConfigureEvent extends XAnyEvent {
+public class XConfigureEvent extends XEvent {
+	public int serial;
+	public int send_event;
+	public int display;
+	public int event;
+	public int window;
 	public int x;
 	public int y;
 	public int width;
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XCreateWindowEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XCreateWindowEvent.java
new file mode 100644
index 0000000000..5211c5a906
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XCreateWindowEvent.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.internal.motif;
+
+ 
+public class XCreateWindowEvent extends XEvent {
+	public int serial;
+	public int send_event;
+	public int display;
+	public int parent;
+	public int window;
+	public int x;
+	public int y;
+	public int width;
+	public int height;
+	public int border_width;
+	public int override_redirect;
+	public static final int sizeof = 48;
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XDestroyWindowEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XDestroyWindowEvent.java
new file mode 100644
index 0000000000..285dd11751
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XDestroyWindowEvent.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.internal.motif;
+
+ 
+public class XDestroyWindowEvent extends XEvent {
+	public int serial;
+	public int send_event;
+	public int display;
+	public int event;
+	public int window;
+	public static final int sizeof = 24;
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XEvent.java
index 835bf0eb32..fed8122810 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XEvent.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XEvent.java
@@ -11,7 +11,7 @@
 package org.eclipse.swt.internal.motif;
 
  
-public abstract class XEvent {
+public class XEvent {
 	public int type;
 	public static final int sizeof = 96;
 }
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XPropertyEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XPropertyEvent.java
new file mode 100644
index 0000000000..9a4f6b2077
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XPropertyEvent.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.internal.motif;
+
+ 
+public class XPropertyEvent extends XAnyEvent {
+	public int atom;
+	public int time;
+	public int state;
+	public static final int sizeof = 40;
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XReparentEvent.java b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XReparentEvent.java
new file mode 100644
index 0000000000..fc7a30076f
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/motif/org/eclipse/swt/internal/motif/XReparentEvent.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.internal.motif;
+
+ 
+public class XReparentEvent extends XEvent {
+	public int serial;
+	public int send_event;
+	public int display;
+	public int event;
+	public int window;
+	public int parent;
+	public int x;
+	public int y;
+	public int override_redirect;
+	public static final int sizeof = 40;
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/SWT.java b/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/SWT.java
index 0ce583c8ed..1517bbe8b2 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/SWT.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/SWT.java
@@ -787,17 +787,19 @@ public class SWT {
 	 * <li><code>Menu</code></li>
 	 * </ul></p>
 	 * 
-	 * <p>
-	 * <b>NOTE:</b> This API element is part of an interim API that is still under
-	 * development and is expected to change significantly before reaching stability.
-	 * It is being made available at this early stage to solicit feedback from
-	 * pioneering adopters on the understanding that any code that uses this API
-	 * will almost certainly be broken (repeatedly) as the API evolves.
-	 * </p>
-	 * 
-	 * @since 2.1
+	 * @since 3.0
 	 */
 	public static final int MIRRORED = 1 << 27;
+	
+	/**
+	 * Style constant to allow embedding (value is 1&lt;&lt;1).
+	 * <p><b>Used By:</b><ul>
+	 * <li><code>Composite</code></li>
+	 * </ul></p>
+	 * 
+	 * @since 3.0
+	 */
+	public static final int EMBEDDED = 1 << 1;
 
 	/**
 	 * Style constant for align up behavior (value is 1&lt;&lt;7,
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Composite.java b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Composite.java
index 821b5447c0..c1e4ef48a3 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Composite.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Composite.java
@@ -11,6 +11,7 @@
 package org.eclipse.swt.widgets;
 
 
+import org.eclipse.swt.internal.*;
 import org.eclipse.swt.internal.motif.*;
 import org.eclipse.swt.*;
 import org.eclipse.swt.graphics.*;
@@ -40,9 +41,13 @@ import org.eclipse.swt.graphics.*;
  */
 public class Composite extends Scrollable {
 	Layout layout;
-	int focusHandle, damagedRegion;
+	public int embeddedHandle;
+	int focusHandle, damagedRegion, clientWindow;
 	Control [] tabList;
 	
+	static byte [] _XEMBED_INFO = Converter.wcsToMbcs (null, "_XEMBED_INFO", true);
+	static byte[] _XEMBED = Converter.wcsToMbcs (null, "_XEMBED", true);
+
 Composite () {
 	/* Do nothing */
 }
@@ -184,6 +189,20 @@ void createHandle (int index) {
 		focusHandle = OS.XmCreateDrawingArea (handle, null, argList, argList.length / 2);
 		if (focusHandle == 0) error (SWT.ERROR_NO_HANDLES);
 	}
+	if ((style & SWT.EMBEDDED) != 0) {
+		Shell shell = getShell ();
+		if (shell.focusProxy == 0) {
+			int [] argList = {OS.XmNx, -1, OS.XmNy, -1, OS.XmNwidth, 1, OS.XmNheight, 1};
+			int focusProxy = OS.XmCreateDrawingArea (shell.shellHandle, null, argList, argList.length / 2);
+			if (focusProxy == 0) error (SWT.ERROR_NO_HANDLES);
+			shell.focusProxy = focusProxy;
+			OS.XtSetMappedWhenManaged (focusProxy, false);
+			OS.XtManageChild (focusProxy);
+			OS.XtSetMappedWhenManaged (focusProxy, true);
+		}
+		if (!OS.XtIsRealized (handle)) shell.realizeWidget ();
+		embeddedHandle = OS.XtWindow (handle);
+	}
 }
 void createScrolledHandle (int topHandle) {
 	int [] argList = {OS.XmNancestorSensitive, 1};
@@ -235,6 +254,46 @@ int focusHandle () {
 	if (focusHandle == 0) return super.focusHandle ();
 	return focusHandle;
 }
+int focusProc (int w, int client_data, int call_data, int continue_to_dispatch) {
+	XFocusChangeEvent xEvent = new XFocusChangeEvent ();
+	OS.memmove (xEvent, call_data, XFocusChangeEvent.sizeof);
+	int handle = OS.XtWindowToWidget (xEvent.display, xEvent.window);
+	Shell shell = getShell ();
+	if (handle != shell.shellHandle) {
+		return super.XFocusChange (w, client_data, call_data, continue_to_dispatch);
+	}
+	if (xEvent.mode != OS.NotifyNormal) return 0;
+	switch (xEvent.detail) {
+		case OS.NotifyNonlinear:
+		case OS.NotifyNonlinearVirtual: {
+			switch (xEvent.type) {
+				case OS.FocusIn: 
+					sendClientEvent (OS.CurrentTime, OS.XEMBED_WINDOW_ACTIVATE, 0, 0, 0);	
+					break;
+				case OS.FocusOut:
+					sendClientEvent (OS.CurrentTime, OS.XEMBED_WINDOW_DEACTIVATE, 0, 0, 0);	
+					break;
+			}
+		}
+	}
+	return 0;
+}
+boolean fowardKeyEvent (int event) {
+	if (clientWindow == 0) return false;
+	boolean warnings = display.getWarnings ();
+	display.setWarnings (false);
+	XKeyEvent xEvent = new XKeyEvent ();
+	OS.memmove (xEvent, event, XKeyEvent.sizeof);
+	xEvent.window = clientWindow;
+	int newEvent = OS.XtMalloc (XEvent.sizeof);
+	OS.memmove (newEvent, xEvent, XKeyEvent.sizeof);
+	int xDisplay = OS.XtDisplay (handle);
+	OS.XSendEvent (xDisplay, clientWindow, false, 0, newEvent);
+	OS.XSync (xDisplay, false);
+	OS.XtFree (newEvent);
+	display.setWarnings (warnings);
+	return true;
+}
 /**
  * Returns an array containing the receiver's children.
  * <p>
@@ -315,6 +374,14 @@ void hookEvents () {
 	if ((state & CANVAS) != 0) {
 		OS.XtInsertEventHandler (handle, 0, true, display.windowProc, NON_MASKABLE, OS.XtListTail);
 	}
+	if ((style & SWT.EMBEDDED) != 0) {
+		int focusProc = display.focusProc;
+		int windowProc = display.windowProc;
+		OS.XtInsertEventHandler (handle, OS.StructureNotifyMask | OS.SubstructureNotifyMask, false, windowProc, STRUCTURE_NOTIFY, OS.XtListTail);		OS.XtInsertEventHandler (handle, OS.PropertyChangeMask, false, windowProc, PROPERTY_CHANGE, OS.XtListTail);
+		OS.XtInsertEventHandler (handle, 0, true, windowProc, NON_MASKABLE, OS.XtListTail);
+		Shell shell = getShell ();
+		OS.XtInsertEventHandler (shell.shellHandle, OS.FocusChangeMask, false, focusProc, handle, OS.XtListTail);
+	}
 }
 
 boolean hooksKeys () {
@@ -511,6 +578,12 @@ void releaseHandle () {
 	focusHandle = 0;
 }
 void releaseWidget () {
+	if ((style & SWT.EMBEDDED) != 0) {
+		Shell shell = getShell ();
+		int focusProc = display.focusProc;
+		OS.XtRemoveEventHandler (shell.shellHandle, OS.FocusChangeMask, false, focusProc, handle);
+		setClientWindow (0);
+	}
 	releaseChildren ();
 	super.releaseWidget ();
 	layout = null;
@@ -518,6 +591,38 @@ void releaseWidget () {
 	if (damagedRegion != 0) OS.XDestroyRegion (damagedRegion);
 	damagedRegion = 0;
 }
+void resizeClientWindow	() {
+	if (clientWindow == 0) return;
+	boolean warnings = display.getWarnings ();
+	display.setWarnings (false);
+	int [] argList = {OS.XmNwidth, 0, OS.XmNheight, 0};
+	OS.XtGetValues (handle, argList, argList.length / 2);
+	int xDisplay = OS.XtDisplay (handle);
+	OS.XMoveResizeWindow (xDisplay, clientWindow, 0, 0, Math.max(1, argList [1]), Math.max(1, argList [3]));
+	display.setWarnings (warnings);
+}
+void sendClientEvent (int time, int message, int detail, int data1, int data2) {
+	if (clientWindow == 0) return;
+	boolean warnings = display.getWarnings ();
+	display.setWarnings (false);
+	int xDisplay = OS.XtDisplay (handle);
+	XClientMessageEvent xEvent = new XClientMessageEvent ();
+	xEvent.type = OS.ClientMessage;
+	xEvent.window = clientWindow;
+	xEvent.message_type = OS.XInternAtom (xDisplay, _XEMBED, false);
+	xEvent.format = 32;
+	xEvent.data [0] = time != 0 ? time : OS.XtLastTimestampProcessed (xDisplay);
+	xEvent.data [1] = message;
+	xEvent.data [2] = detail;
+	xEvent.data [3] = data1;
+	xEvent.data [4] = data2;
+	int event = OS.XtMalloc (XEvent.sizeof);
+	OS.memmove (event, xEvent, XClientMessageEvent.sizeof);
+	OS.XSendEvent (xDisplay, clientWindow, false, 0, event);
+	OS.XSync (xDisplay, false);
+	OS.XtFree (event);
+	display.setWarnings (warnings);
+}
 void setBackgroundPixel (int pixel) {
 	super.setBackgroundPixel (pixel);
 	if ((state & CANVAS) != 0) {
@@ -541,9 +646,36 @@ boolean setBounds (int x, int y, int width, int height, boolean move, boolean re
 			OS.XtConfigureWidget (focusHandle, 0, 0, argList [1], argList [3], 0);
 		}
 		if (layout != null) layout.layout (this, false);
+		if ((style & SWT.EMBEDDED) != 0) resizeClientWindow ();
 	}
 	return changed;
 }
+void setClientWindow (int window) {
+	if (window == OS.XtWindow (focusHandle)) return;
+	boolean warnings = display.getWarnings ();
+	display.setWarnings (false);
+	int xDisplay = OS.XtDisplay (handle);
+	if (window != 0) {
+		clientWindow = window;
+		sendClientEvent (0, OS.XEMBED_EMBEDDED_NOTIFY, 0, 0, 0);
+		OS.XtRegisterDrawable (xDisplay, clientWindow, handle);
+		OS.XSelectInput (xDisplay, clientWindow, OS.PropertyChangeMask);
+		updateMapped ();		
+		resizeClientWindow ();
+		Shell shell = getShell ();
+		if (shell == display.getActiveShell ()) {
+			shell.bringToTop (true);
+			sendClientEvent (0, OS.XEMBED_WINDOW_ACTIVATE, 0, 0, 0);
+			if (this == display.getFocusControl ()) {
+				sendClientEvent (0, OS.XEMBED_FOCUS_IN, OS.XEMBED_FOCUS_CURRENT, 0, 0);
+			}
+		}
+	} else {
+		OS.XtUnregisterDrawable (xDisplay, clientWindow);
+		clientWindow = 0;
+	}
+	display.setWarnings (warnings);
+}
 public boolean setFocus () {
 	checkWidget ();
 	if ((style & SWT.NO_FOCUS) != 0) return false;
@@ -614,7 +746,7 @@ boolean setTabGroupFocus () {
 	if ((style & SWT.NO_FOCUS) == 0) {
 		boolean takeFocus = true;
 		if ((state & CANVAS) != 0) takeFocus = hooksKeys ();
-		if (takeFocus && setTabItemFocus ()) return true;
+		if ((takeFocus || (style & SWT.EMBEDDED) != 0) && setTabItemFocus ()) return true;
 	}
 	Control [] children = _getChildren ();
 	for (int i=0; i<children.length; i++) {
@@ -627,7 +759,7 @@ boolean setTabItemFocus () {
 	if ((style & SWT.NO_FOCUS) == 0) {
 		boolean takeFocus = true;
 		if ((state & CANVAS) != 0) takeFocus = hooksKeys ();
-		if (takeFocus) {
+		if (takeFocus || (style & SWT.EMBEDDED) != 0) {
 			if (!isShowing ()) return false;
 			if (forceFocus ()) return true;
 		}
@@ -650,6 +782,10 @@ boolean translateMnemonic (char key, XKeyEvent xEvent) {
 	}
 	return false;
 }
+boolean translateTraversal (int key, XKeyEvent xEvent) {
+	if ((style & SWT.EMBEDDED) != 0) return false;
+	return super.translateTraversal (key, xEvent);
+}
 int XButtonPress (int w, int client_data, int call_data, int continue_to_dispatch) {
 	int result = super.XButtonPress (w, client_data, call_data, continue_to_dispatch);
 
@@ -715,12 +851,135 @@ int XExposure (int w, int client_data, int call_data, int continue_to_dispatch)
 	damagedRegion = 0;
 	return 0;
 }
+int xFocusIn (XFocusChangeEvent xEvent) {
+	int result = super.xFocusIn (xEvent);
+	if (handle != 0 && (style & SWT.EMBEDDED) != 0) {
+		sendClientEvent (0, OS.XEMBED_FOCUS_IN, OS.XEMBED_FOCUS_CURRENT, 0, 0);
+	}
+	return result;
+}
+int xFocusOut (XFocusChangeEvent xEvent) {
+	int result = super.xFocusOut (xEvent);
+	if (handle != 0 && (style & SWT.EMBEDDED) != 0) {
+		sendClientEvent (0, OS.XEMBED_FOCUS_OUT, 0, 0, 0);
+	}
+	return result;
+}
+int XKeyPress (int w, int client_data, int call_data, int continue_to_dispatch) {
+	if ((style & SWT.EMBEDDED) != 0) {
+		if (fowardKeyEvent (call_data)) return 0;
+	}
+	return super.XKeyPress (w, client_data, call_data, continue_to_dispatch);
+}
+int XKeyRelease (int w, int client_data, int call_data, int continue_to_dispatch) {
+	if ((style & SWT.EMBEDDED) != 0) {
+		if (fowardKeyEvent (call_data)) return 0;
+	}
+	return super.XKeyRelease (w, client_data, call_data, continue_to_dispatch);
+}
 int XNonMaskable (int w, int client_data, int call_data, int continue_to_dispatch) {
+	if ((style & SWT.EMBEDDED) != 0) {
+		XEvent xEvent = new XEvent ();
+		OS.memmove (xEvent, call_data, XEvent.sizeof);
+		if (xEvent.type == OS.ClientMessage) {
+			XClientMessageEvent xClientEvent = new XClientMessageEvent ();
+			OS.memmove (xClientEvent, call_data, XClientMessageEvent.sizeof);
+			int xDisplay = OS.XtDisplay (handle);
+			if (xClientEvent.message_type == OS.XInternAtom (xDisplay, _XEMBED, false)) {
+				int type = xClientEvent.data [1];
+				switch (type) {
+					case OS.XEMBED_REQUEST_FOCUS: {
+						setFocus ();
+						break;
+					}
+					case OS.XEMBED_FOCUS_PREV: {
+						traverse (SWT.TRAVERSE_TAB_PREVIOUS);
+						break;
+					}
+					case OS.XEMBED_FOCUS_NEXT: {
+						traverse (SWT.TRAVERSE_TAB_NEXT);
+						break;
+					}
+				}
+			}
+			return 0;
+		}
+	}
 	if ((state & CANVAS) != 0) {
-		XAnyEvent xEvent = new XAnyEvent ();
-		OS.memmove (xEvent, call_data, XAnyEvent.sizeof);
-		if (xEvent.type == OS.GraphicsExpose) return XExposure (w, client_data, call_data, continue_to_dispatch);
+		XEvent xEvent = new XEvent ();
+		OS.memmove (xEvent, call_data, XEvent.sizeof);
+		if (xEvent.type == OS.GraphicsExpose) {
+			return XExposure (w, client_data, call_data, continue_to_dispatch);
+		}
 	}
 	return 0;
 }
+int XPropertyChange (int w, int client_data, int call_data, int continue_to_dispatch) {
+	int result = super.XPropertyChange (w, client_data, call_data, continue_to_dispatch);
+	if ((style & SWT.EMBEDDED) != 0) {
+		XPropertyEvent xPropertyEvent = new XPropertyEvent ();
+		OS.memmove(xPropertyEvent, call_data, XPropertyEvent.sizeof);
+		if (xPropertyEvent.window == clientWindow) {
+			int atom = xPropertyEvent.atom;
+			int xDisplay = xPropertyEvent.display;
+			if (atom == OS.XInternAtom (xDisplay, _XEMBED_INFO, false)) {
+				updateMapped ();
+			}
+		}
+	}
+	return result;
+}
+int XStructureNotify (int w, int client_data, int call_data, int continue_to_dispatch) {
+	int result = super.XStructureNotify (w, client_data, call_data, continue_to_dispatch);
+	if ((style & SWT.EMBEDDED) != 0) {
+		XEvent xEvent = new XEvent ();
+		OS.memmove (xEvent, call_data, XEvent.sizeof);
+		switch (xEvent.type) {
+			case OS.ReparentNotify: {
+				XReparentEvent xReparentEvent = new XReparentEvent ();
+				OS.memmove (xReparentEvent, call_data, XReparentEvent.sizeof);
+				if (clientWindow == 0) setClientWindow (xReparentEvent.window);
+				break;
+			}
+			case OS.CreateNotify: {
+				XCreateWindowEvent xCreateEvent = new XCreateWindowEvent ();
+				OS.memmove (xCreateEvent, call_data, XCreateWindowEvent.sizeof);
+				if (clientWindow == 0) setClientWindow (xCreateEvent.window);
+				break;
+			}
+			case OS.DestroyNotify: {
+				XDestroyWindowEvent xDestroyEvent = new XDestroyWindowEvent ();
+				OS.memmove (xDestroyEvent, call_data, XDestroyWindowEvent.sizeof);
+				if (xDestroyEvent.window == clientWindow) setClientWindow (0);
+				break;
+			}
+		}
+	}
+	return result;
+}
+void updateMapped () {
+	if (clientWindow == 0) return;
+	boolean warnings = display.getWarnings ();
+	display.setWarnings (false);
+	int xDisplay = OS.XtDisplay (handle);
+	int prop = OS.XInternAtom (xDisplay, _XEMBED_INFO, false);
+	int [] type = new int [1], format = new int [1];
+	int [] nitems = new int [1], bytes_after = new int [1], data = new int [1];
+	if (OS.XGetWindowProperty (xDisplay, clientWindow, prop, 0, 2, false, prop, type, format, nitems, bytes_after, data) == 0) {
+		if (type [0] == prop) {
+			if (nitems [0] >= 2) {
+				int [] buffer = new int [2];
+				OS.memmove (buffer, data [0], buffer.length * 4);
+				int flags = buffer [1];
+				if ((flags & OS.XEMBED_MAPPED) != 0) {
+					OS.XMapWindow (xDisplay, clientWindow);
+				} else {
+					OS.XUnmapWindow (xDisplay, clientWindow);
+				}
+			}
+		}
+	}
+	if (data [0] != 0) OS.XFree (data [0]);
+	display.setWarnings (warnings);
+}
 }
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Display.java b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Display.java
index b352c3a06f..bf8f3b9c9b 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Display.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Display.java
@@ -284,6 +284,10 @@ public class Display extends Device {
 	int checkResizeProc, resizeWidth, resizeHeight, resizeCount, resizeWindow;
 	XConfigureEvent xConfigureEvent = new XConfigureEvent ();
 	
+	/* Focus Proc */
+	Callback focusCallback;
+	int focusProc;
+
 	/* Wake and Sleep */
 	Callback wakeCallback;
 	int wakeProc, read_fd, write_fd, inputID;
@@ -856,6 +860,11 @@ public Widget findWidget (int handle) {
 	checkDevice ();
 	return getWidget (handle);
 }
+int focusProc (int w, int client_data, int call_data, int continue_to_dispatch) {
+	Widget widget = getWidget (client_data);
+	if (widget == null) return 0;
+	return widget.focusProc (w, client_data, call_data, continue_to_dispatch);
+}
 /**
  * Returns the currently active <code>Shell</code>, or null
  * if no shell belonging to the currently running application
@@ -1521,6 +1530,9 @@ void initializeDialog () {
 void initializeDisplay () {
 	
 	/* Create the callbacks */
+	focusCallback = new Callback (this, "focusProc", 4);
+	focusProc = focusCallback.getAddress ();
+	if (focusProc == 0) error (SWT.ERROR_NO_MORE_CALLBACKS);
 	windowCallback = new Callback (this, "windowProc", 4);
 	windowProc = windowCallback.getAddress ();
 	if (windowProc == 0) error (SWT.ERROR_NO_MORE_CALLBACKS);
@@ -2049,6 +2061,9 @@ void releaseDisplay () {
 	wakeProc = 0;
 	OS.close (read_fd);
 	OS.close (write_fd);
+
+	focusCallback.dispose (); focusCallback = null;
+	focusProc = 0;
 		
 	/* Free the font lists */
 	if (buttonFont != null) {
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Shell.java b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Shell.java
index 0ad916c4a4..36cad2e4de 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Shell.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Shell.java
@@ -100,7 +100,7 @@ import org.eclipse.swt.events.*;
  * @see SWT
  */
 public class Shell extends Decorations {
-	int shellHandle;
+	int shellHandle, focusProxy;
 	boolean reparented, realized, configured;
 	int oldX, oldY, oldWidth, oldHeight;
 	Control lastActive;
@@ -468,7 +468,7 @@ void bringToTop (boolean force) {
 	if (!isVisible ()) return;
 	int xDisplay = OS.XtDisplay (shellHandle);
 	if (xDisplay == 0) return;
-	int xWindow = OS.XtWindow (shellHandle);
+	int xWindow = OS.XtWindow (focusProxy != 0 ? focusProxy : shellHandle);
 	if (xWindow == 0) return;
 	if (!force) {
 		int [] buffer1 = new int [1], buffer2 = new int [1];
@@ -1370,7 +1370,12 @@ int XFocusChange (int w, int client_data, int call_data, int continue_to_dispatc
 		case OS.NotifyNonlinear:
 		case OS.NotifyNonlinearVirtual: {
 			switch (xEvent.type) {
-				case OS.FocusIn: 
+				case OS.FocusIn:
+					if (focusProxy != 0) {
+						int xWindow = OS.XtWindow (focusProxy);
+						int xDisplay = OS.XtDisplay (focusProxy);
+						OS.XSetInputFocus (xDisplay, xWindow, OS.RevertToParent, OS.CurrentTime);
+					}
 					postEvent (SWT.Activate);
 					break;
 				case OS.FocusOut:
@@ -1384,6 +1389,10 @@ int XFocusChange (int w, int client_data, int call_data, int continue_to_dispatc
 int XStructureNotify (int w, int client_data, int call_data, int continue_to_dispatch) {
 	XConfigureEvent xEvent = new XConfigureEvent ();
 	OS.memmove (xEvent, call_data, XConfigureEvent.sizeof);
+	int handle = OS.XtWindowToWidget (xEvent.display, xEvent.window);
+	if (handle != shellHandle) {
+		return super.XStructureNotify (w, client_data, call_data, continue_to_dispatch);
+	}
 	switch (xEvent.type) {
 		case OS.ReparentNotify: {
 			if (reparented) return 0;
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Tracker.java b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Tracker.java
index 0a4371efa2..0fdf5c2bd0 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Tracker.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Tracker.java
@@ -395,7 +395,7 @@ public boolean open () {
 	}
 
 	int xEvent = OS.XtMalloc (XEvent.sizeof);
-	XAnyEvent anyEvent = new XAnyEvent();
+	XEvent anyEvent = new XEvent();
 	int [] newX = new int [1], newY = new int [1];
 	int xtContext = OS.XtDisplayToApplicationContext (xDisplay);
 	
@@ -423,7 +423,7 @@ public boolean open () {
 	while (tracking) {
 		if (parent != null && parent.isDisposed ()) break;
 		OS.XtAppNextEvent (xtContext, xEvent);
-		OS.memmove (anyEvent, xEvent, XAnyEvent.sizeof);
+		OS.memmove (anyEvent, xEvent, XEvent.sizeof);
 		switch (anyEvent.type) {
 			case OS.MotionNotify:
 				if (cursor != 0) {
diff --git a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Widget.java b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Widget.java
index dccab0b336..b82c7ac4a9 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Widget.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT/motif/org/eclipse/swt/widgets/Widget.java
@@ -110,7 +110,8 @@ public abstract class Widget {
 	static final int UNMAP_CALLBACK  = 30;
 	static final int DELETE_WINDOW = 31;
 	static final int EXPOSURE_CALLBACK  = 32;
-	static final int MULTIPLE_SELECTION_CALLBACK  = 33;	
+	static final int MULTIPLE_SELECTION_CALLBACK  = 33;
+	static final int PROPERTY_CHANGE = 34;
 
 Widget () {
 	/* Do nothing */
@@ -349,6 +350,9 @@ void error (int code) {
 boolean filters (int eventType) {
 	return display.filters (eventType);
 }
+int focusProc (int w, int client_data, int call_data, int continue_to_dispatch) {
+	return 0;
+}
 /**
  * Returns the application defined widget data associated
  * with the receiver, or null if it has not been set. The
@@ -993,6 +997,7 @@ int windowProc (int w, int client_data, int call_data, int continue_to_dispatch)
 		case KEY_PRESS:					return XKeyPress (w, client_data, call_data, continue_to_dispatch);
 		case KEY_RELEASE:					return XKeyRelease (w, client_data, call_data, continue_to_dispatch);
 		case LEAVE_WINDOW:					return XLeaveWindow (w, client_data, call_data, continue_to_dispatch);
+		case PROPERTY_CHANGE:				return XPropertyChange (w, client_data, call_data, continue_to_dispatch);
 		case ACTIVATE_CALLBACK:			return XmNactivateCallback (w, client_data, call_data);
 		case ARM_CALLBACK:					return XmNarmCallback (w, client_data, call_data);
 		case BROWSE_SELECTION_CALLBACK:	return XmNbrowseSelectionCallback (w, client_data, call_data);
@@ -1051,6 +1056,9 @@ int XLeaveWindow (int w, int client_data, int call_data, int continue_to_dispatc
 int XPointerMotion (int w, int client_data, int call_data, int continue_to_dispatch) {
 	return 0;
 }
+int XPropertyChange (int w, int client_data, int call_data, int continue_to_dispatch) {
+	return 0;
+}
 int XmNactivateCallback (int w, int client_data, int call_data) {
 	return 0;
 }