| /* |
| * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| // TODO: Propogate applicationActive from Java |
| |
| #ifdef HEADLESS |
| #error This file should not be included in headless library |
| #endif |
| |
| #include "awt_p.h" |
| |
| #include <X11/Xproto.h> |
| #include <X11/Xlib.h> |
| #include <X11/Xatom.h> |
| #include <Xm/MwmUtil.h> |
| #ifdef __linux__ |
| #include <execinfo.h> |
| #endif |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| /* JNI headers */ |
| #include "java_awt_Frame.h" /* for frame state constants */ |
| #include "java_awt_event_KeyEvent.h" |
| #include "awt_wm.h" |
| #include "awt_util.h" /* for X11 error handling macros */ |
| #include "awt_xembed.h" |
| #include "awt_Component.h" |
| #include "awt_AWTEvent.h" |
| #include "canvas.h" |
| #include "sun_awt_motif_MEmbedCanvasPeer.h" |
| |
| #ifdef DOTRACE |
| #define MTRACE(param) fprintf(stderr, param) |
| #define MTRACEP1(format, p1) fprintf(stderr, format, p1) |
| #define MTRACEP2(format, p1, p2) fprintf(stderr, format, p1, p2) |
| #define MTRACEP3(format, p1, p2, p3) fprintf(stderr, format, p1, p2, p3) |
| #define MTRACEP4(format, p1, p2, p3, p4) fprintf(stderr, format, p1, p2, p3, p4) |
| #define MTRACEP5(format, p1, p2, p3, p4, p5) fprintf(stderr, format, p1, p2, p3, p4, p5) |
| #define MTRACEP6(format, p1, p2, p3, p4, p5, p6) fprintf(stderr, format, p1, p2, p3, p4, p5, p6) |
| #define MTRACEP7(format, p1, p2, p3, p4, p5, p6, p7) fprintf(stderr, format, p1, p2, p3, p4, p5, p6, p7) |
| #else |
| #define MTRACE(param) |
| #define MTRACEP1(format, p1) |
| #define MTRACEP2(format, p1, p2) |
| #define MTRACEP3(format, p1, p2, p3) |
| #define MTRACEP4(format, p1, p2, p3, p4) |
| #define MTRACEP5(format, p1, p2, p3, p4, p5) |
| #define MTRACEP6(format, p1, p2, p3, p4, p5, p6) |
| #define MTRACEP7(format, p1, p2, p3, p4, p5, p6, p7) |
| #endif |
| |
| /**************************** XEmbed server DnD support ***********************/ |
| extern Atom XA_XdndAware; |
| extern Boolean |
| register_xembed_drop_site(JNIEnv* env, Display* dpy, jobject server, |
| Window serverHandle, Window clientHandle); |
| extern Boolean |
| unregister_xembed_drop_site(JNIEnv* env, Display* dpy, jobject server, |
| Window serverHandle, Window clientHandle); |
| extern void |
| forward_event_to_embedded(Window embedded, jlong ctxt, jint eventID); |
| |
| extern const char * msg_to_str(int msg); |
| |
| void |
| set_xembed_drop_target(JNIEnv* env, jobject server); |
| void |
| remove_xembed_drop_target(JNIEnv* env, jobject server); |
| Boolean |
| is_xembed_client(Window window); |
| /******************************************************************************/ |
| extern struct MComponentPeerIDs mComponentPeerIDs; |
| static jobject createRectangle(JNIEnv* env, int x, int y, int width, int height); |
| static jobject createDimension(JNIEnv* env, int width, int height); |
| static void processXEmbedInfo(JNIEnv* env, jobject this); |
| static Atom XA_XEmbedInfo; |
| static Atom XA_XEmbed; |
| static jmethodID requestXEmbedFocusMID, focusNextMID, focusPrevMID, |
| registerAcceleratorMID, unregisterAcceleratorMID, |
| grabKeyMID, ungrabKeyMID, childResizedMID, |
| setXEmbedDropTargetMID, removeXEmbedDropTargetMID; |
| static jfieldID keysymFID, modifiersFID, applicationActiveFID; |
| |
| typedef struct _xembed_server_data { |
| Window handle; // pointer to plugin intermediate widget, XEmbed client |
| Window serverHandle; |
| Widget serverWidget; |
| Boolean dispatching; // whether we dispatch messages for handle |
| int version; |
| jobject server; |
| struct _xembed_server_data * next; |
| } xembed_server_data, * pxembed_server_data; |
| |
| static pxembed_server_data xembed_list = NULL; |
| |
| static pxembed_server_data |
| getData(Window handle) { |
| pxembed_server_data temp = xembed_list; |
| while (temp != NULL) { |
| if (temp->handle == handle) { |
| return temp; |
| } |
| temp = temp->next; |
| } |
| return NULL; |
| } |
| |
| static pxembed_server_data |
| getDataByEmbedder(jobject server) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| pxembed_server_data temp = xembed_list; |
| DASSERT(server != NULL); |
| while (temp != NULL) { |
| if ((*env)->IsSameObject(env, temp->server, server)) { |
| return temp; |
| } |
| temp = temp->next; |
| } |
| return NULL; |
| } |
| |
| static pxembed_server_data |
| getDataByServerHandle(Window serverHandle) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| pxembed_server_data temp = xembed_list; |
| Widget serverWidget = NULL; |
| if (serverHandle == None) { |
| return NULL; |
| } |
| serverWidget = XtWindowToWidget(awt_display, serverHandle); |
| while (temp != NULL) { |
| if (temp->serverHandle == serverHandle || temp->serverWidget == serverWidget) { |
| temp->serverHandle = serverWidget; |
| return temp; |
| } |
| temp = temp->next; |
| } |
| return NULL; |
| } |
| |
| static pxembed_server_data |
| addData(jobject server) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| struct ComponentData *cdata; |
| xembed_server_data * data = malloc(sizeof(xembed_server_data)); |
| DASSERT(server != NULL); |
| memset(data, 0, sizeof(xembed_server_data)); |
| data->server = server; |
| cdata = (struct ComponentData *) |
| JNU_GetLongFieldAsPtr(env, server, mComponentPeerIDs.pData); |
| DASSERT(cdata != NULL); |
| data->serverHandle = XtWindow(cdata->widget); |
| data->serverWidget = cdata->widget; |
| data->next = xembed_list; |
| xembed_list = data; |
| return data; |
| } |
| |
| static void |
| removeData(jobject server) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| pxembed_server_data * temp = &xembed_list; |
| DASSERT(server != NULL); |
| while (*temp != NULL) { |
| if ((*env)->IsSameObject(env, (*temp)->server, server)) { |
| xembed_server_data * data = *temp; |
| *temp = (*temp)->next; |
| DASSERT(data->server != NULL); |
| (*env)->DeleteGlobalRef(env, data->server); |
| free(data); |
| return; |
| } |
| temp = &(*temp)->next; |
| } |
| } |
| |
| void |
| initXEmbedServerData() { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| jclass clazz; |
| MTRACE("initXEmbedServerData\n"); |
| XA_XEmbedInfo = XInternAtom(awt_display, "_XEMBED_INFO", False); |
| XA_XEmbed = XInternAtom(awt_display, "_XEMBED", False); |
| |
| clazz = (*env)->FindClass(env, "sun/awt/motif/MEmbedCanvasPeer"); |
| DASSERT(clazz != NULL); |
| requestXEmbedFocusMID = (*env)->GetMethodID(env, clazz, "requestXEmbedFocus", "()V"); |
| DASSERT(requestXEmbedFocusMID != NULL); |
| focusNextMID = (*env)->GetMethodID(env, clazz, "focusNext", "()V"); |
| DASSERT(focusNextMID != NULL); |
| focusPrevMID = (*env)->GetMethodID(env, clazz, "focusPrev", "()V"); |
| DASSERT(focusPrevMID != NULL); |
| registerAcceleratorMID = (*env)->GetMethodID(env, clazz, "registerAccelerator", "(JJJ)V"); |
| DASSERT(registerAcceleratorMID != NULL); |
| unregisterAcceleratorMID = (*env)->GetMethodID(env, clazz, "unregisterAccelerator", "(J)V"); |
| DASSERT(unregisterAcceleratorMID != NULL); |
| grabKeyMID = (*env)->GetMethodID(env, clazz, "grabKey", "(JJ)V"); |
| DASSERT(grabKeyMID != NULL); |
| ungrabKeyMID = (*env)->GetMethodID(env, clazz, "ungrabKey", "(JJ)V"); |
| DASSERT(ungrabKeyMID != NULL); |
| childResizedMID = (*env)->GetMethodID(env, clazz, "childResized", "()V"); |
| DASSERT(childResizedMID != NULL); |
| setXEmbedDropTargetMID = |
| (*env)->GetMethodID(env, clazz, "setXEmbedDropTarget", "()V"); |
| DASSERT(setXEmbedDropTargetMID != NULL); |
| removeXEmbedDropTargetMID = |
| (*env)->GetMethodID(env, clazz, "removeXEmbedDropTarget", "()V"); |
| DASSERT(removeXEmbedDropTargetMID != NULL); |
| |
| applicationActiveFID = (*env)->GetFieldID(env, clazz, "applicationActive", "Z"); |
| DASSERT(applicationActiveFID != NULL); |
| (*env)->DeleteLocalRef(env, clazz); |
| |
| clazz = (*env)->FindClass(env, "sun/awt/motif/GrabbedKey"); |
| DASSERT(clazz != NULL); |
| keysymFID = (*env)->GetFieldID(env, clazz, "keysym", "J"); |
| DASSERT(keysymFID != NULL); |
| modifiersFID = (*env)->GetFieldID(env, clazz, "modifiers", "J"); |
| DASSERT(modifiersFID != NULL); |
| (*env)->DeleteLocalRef(env, clazz); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: initXEmbedServer |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_initXEmbedServer(JNIEnv *env, jobject this) { |
| struct ComponentData *cdata; |
| AWT_LOCK(); |
| MTRACE("initXEmbedServer\n"); |
| addData((*env)->NewGlobalRef(env, this)); |
| if (XA_XEmbedInfo == None) { |
| initXEmbedServerData(); |
| } |
| cdata = (struct ComponentData *) |
| JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData); |
| /* XSelectInput(awt_display, XtWindow(cdata->widget), SubstructureNotifyMask); */ |
| XtAddEventHandler(cdata->widget, |
| SubstructureNotifyMask, |
| False, null_event_handler, NULL); |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: destroyXEmbedServer |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_destroyXEmbedServer(JNIEnv *env, jobject this) { |
| AWT_LOCK(); |
| MTRACE("destroyXEmbedServer\n"); |
| removeData(this); |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: isXEmbedActive |
| * Signature: ()Z |
| */ |
| JNIEXPORT jboolean JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_isXEmbedActive(JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| jboolean res = JNI_FALSE; |
| AWT_LOCK(); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| res = (sdata->handle != None)?JNI_TRUE:JNI_FALSE; |
| } |
| AWT_UNLOCK(); |
| return res; |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: initDispatching |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_initDispatching (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("initDispatching\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| XSelectInput(awt_display, sdata->handle, StructureNotifyMask | PropertyChangeMask); |
| sdata->dispatching = True; |
| register_xembed_drop_site(env, awt_display, sdata->server, |
| sdata->serverHandle, sdata->handle); |
| } |
| processXEmbedInfo(env, this); |
| Java_sun_awt_motif_MEmbedCanvasPeer_notifyChildEmbedded(env, this); |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: endDispatching |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_endDispatching (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("endDispatching\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| unregister_xembed_drop_site(env, awt_display, sdata->server, |
| sdata->serverHandle, sdata->handle); |
| sdata->dispatching = False; |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: embedChild |
| * Signature: (J)V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_embedChild (JNIEnv * env, jobject this, jlong handle) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("embedChild\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| if (sdata->handle != None) { |
| Java_sun_awt_motif_MEmbedCanvasPeer_detachChild(env, this); |
| } |
| sdata->handle = (Window)handle; |
| Java_sun_awt_motif_MEmbedCanvasPeer_initDispatching(env, this); |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: childDestroyed |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_childDestroyed (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("childDestroyed\n"); |
| Java_sun_awt_motif_MEmbedCanvasPeer_endDispatching(env, this); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| sdata->handle = None; |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: getEmbedPreferredSize |
| * Signature: ()Ljava/awt/Dimension; |
| */ |
| JNIEXPORT jobject JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_getEmbedPreferredSize (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| jobject res = NULL; |
| XSizeHints * hints; |
| long dummy; |
| AWT_LOCK(); |
| MTRACE("getPreferredSize\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| hints = XAllocSizeHints(); |
| DASSERT(hints != NULL); |
| DASSERT(sdata->handle != None); |
| if (XGetWMNormalHints(awt_display, sdata->handle, hints, &dummy) == Success) { |
| res = createDimension(env, hints->width, hints->height); |
| } |
| XFree(hints); |
| } |
| AWT_UNLOCK(); |
| return res; |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: getEmbedMinimumSize |
| * Signature: ()Ljava/awt/Dimension; |
| */ |
| JNIEXPORT jobject JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_getEmbedMinimumSize (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| jobject res = NULL; |
| XSizeHints * hints; |
| long dummy; |
| AWT_LOCK(); |
| MTRACE("getMinimumSize\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| hints = XAllocSizeHints(); |
| DASSERT(hints != NULL); |
| DASSERT(sdata->handle != None); |
| if (XGetWMNormalHints(awt_display, sdata->handle, hints, &dummy) == Success) { |
| res = createDimension(env, hints->min_width, hints->min_height); |
| } |
| XFree(hints); |
| } |
| AWT_UNLOCK(); |
| return res; |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: getClientBounds |
| * Signature: ()Ljava/awt/Rectangle; |
| */ |
| JNIEXPORT jobject JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_getClientBounds (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| jobject res = NULL; |
| AWT_LOCK(); |
| MTRACE("getClientBounds\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| XWindowAttributes attrs; |
| DASSERT(sdata->handle != None); |
| if (XGetWindowAttributes(awt_display, sdata->handle, &attrs) == Success) { |
| res = createRectangle(env, attrs.x, attrs.y, attrs.width, attrs.height); |
| } |
| } |
| AWT_UNLOCK(); |
| return res; |
| } |
| |
| Boolean |
| isApplicationActive(JNIEnv * env, jobject this) { |
| return (*env)->GetBooleanField(env, this, applicationActiveFID); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: notifyChildEmbedded |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_notifyChildEmbedded (JNIEnv *env, jobject this) { |
| struct ComponentData *cdata; |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("notifyChildEmbedded\n"); |
| cdata = (struct ComponentData *) |
| JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| DASSERT(sdata->handle != None); |
| DASSERT(cdata != NULL); |
| DASSERT(XtWindow(cdata->widget) != None); |
| sendMessageHelper(sdata->handle, XEMBED_EMBEDDED_NOTIFY, XtWindow(cdata->widget), min(sdata->version, XEMBED_VERSION), 0); |
| if (isApplicationActive(env, this)) { |
| sendMessage(sdata->handle, XEMBED_WINDOW_ACTIVATE); |
| } |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: detachChild |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_detachChild (JNIEnv *env, jobject this) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("detachChild\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| /** |
| * XEmbed specification: |
| * "The embedder can unmap the client and reparent the client window to the root window. If the |
| * client receives an ReparentNotify event, it should check the parent field of the XReparentEvent |
| * structure. If this is the root window of the window's screen, then the protocol is finished and |
| * there is no further interaction. If it is a window other than the root window, then the protocol |
| * continues with the new parent acting as the embedder window." |
| */ |
| DASSERT(sdata->handle != None); |
| XUnmapWindow(awt_display, sdata->handle); |
| XReparentWindow(awt_display, sdata->handle, DefaultRootWindow(awt_display), 0, 0); |
| Java_sun_awt_motif_MEmbedCanvasPeer_endDispatching(env, this); |
| sdata->handle = None; |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: forwardKeyEvent |
| * Signature: (Ljava/awt/event/KeyEvent;)V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_forwardKeyEvent (JNIEnv *env, jobject this, jobject event) { |
| pxembed_server_data sdata; |
| jbyteArray array; |
| XEvent *xevent; |
| AWT_LOCK(); |
| MTRACE("forwardKeyEvent\n"); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| DASSERT(sdata->handle != None); |
| array = (jbyteArray)(*env)->GetObjectField(env, event, awtEventIDs.bdata); |
| if (array == NULL) { |
| MTRACE("array is null\n"); |
| AWT_UNLOCK(); |
| return; |
| } |
| |
| xevent = (XEvent *)(*env)->GetByteArrayElements(env, array, NULL); |
| if (xevent == NULL) { |
| (*env)->DeleteLocalRef(env, array); |
| MTRACE("xevent is null\n"); |
| AWT_UNLOCK(); |
| return; |
| } |
| xevent->xany.window = sdata->handle; |
| XSendEvent(awt_display, sdata->handle, False, NoEventMask, xevent); |
| (*env)->DeleteLocalRef(env, array); |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: getAWTKeyCodeForKeySym |
| * Signature: (I)I |
| */ |
| JNIEXPORT jint JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_getAWTKeyCodeForKeySym (JNIEnv *env, jobject this, jint keysym) { |
| jint keycode = java_awt_event_KeyEvent_VK_UNDEFINED; |
| Boolean mapsToUnicodeChar; |
| jint keyLocation; |
| keysymToAWTKeyCode(keysym, &keycode, &mapsToUnicodeChar, &keyLocation); |
| return keycode; |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: sendMessage |
| * Signature: (I)V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_sendMessage__I (JNIEnv *env, jobject this, jint msg) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACEP2("sendMessage %d(%s)\n", msg, msg_to_str(msg)); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| DASSERT(sdata->handle != None); |
| sendMessage(sdata->handle, msg); |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: sendMessage |
| * Signature: (IJJJ)V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_sendMessage__IJJJ (JNIEnv *env, jobject this, jint msg, jlong detail, jlong data1, jlong data2) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACEP5("sendMessage2 msg %d(%s) detail %d data: %d %d\n", msg, msg_to_str(msg), detail, data1, data2); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| DASSERT(sdata->handle != None); |
| sendMessageHelper(sdata->handle, msg, detail, data1, data2); |
| } |
| AWT_UNLOCK(); |
| } |
| |
| static jobject |
| createRectangle(JNIEnv* env, int x, int y, int width, int height) { |
| static jclass clazz; |
| static jmethodID mid; |
| jobject rect = NULL; |
| if (mid == 0) { |
| jclass l_clazz = (*env)->FindClass(env, "java/awt/Rectangle"); |
| DASSERT(l_clazz != NULL); |
| mid = (*env)->GetMethodID(env, clazz, "<init>", "(IIII)V"); |
| DASSERT(mid != NULL); |
| clazz = (*env)->NewGlobalRef(env, l_clazz); |
| (*env)->DeleteLocalRef(env, l_clazz); |
| } |
| if (mid != NULL) { |
| rect = (*env)->NewObject(env, clazz, mid, x, y, width, height); |
| if ((*env)->ExceptionOccurred(env)) { |
| return NULL; |
| } |
| } |
| return rect; |
| } |
| |
| static jobject |
| createDimension(JNIEnv* env, int width, int height) { |
| static jclass clazz; |
| static jmethodID mid; |
| jobject dim = NULL; |
| if (mid == 0) { |
| jclass l_clazz = (*env)->FindClass(env, "java/awt/Dimension"); |
| DASSERT(l_clazz != NULL); |
| mid = (*env)->GetMethodID(env, clazz, "<init>", "(II)V"); |
| DASSERT(mid != NULL); |
| clazz = (*env)->NewGlobalRef(env, l_clazz); |
| (*env)->DeleteLocalRef(env, l_clazz); |
| } |
| if (mid != NULL) { |
| dim = (*env)->NewObject(env, clazz, mid, width, height); |
| if ((*env)->ExceptionOccurred(env)) { |
| return NULL; |
| } |
| } |
| return dim; |
| } |
| |
| Boolean isMapped(Window w) { |
| XWindowAttributes attr; |
| Status status = 0; |
| WITH_XERROR_HANDLER(xerror_ignore_bad_window); |
| status = XGetWindowAttributes(awt_display, w, &attr); |
| RESTORE_XERROR_HANDLER; |
| if (status == 0 || xerror_code != Success) { |
| return False; |
| } |
| return !(attr.map_state == IsUnmapped); |
| } |
| |
| static void |
| processXEmbedInfo(JNIEnv * env, jobject this) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("processXEmbedInfo\n"); |
| sdata = getDataByEmbedder(this); |
| if (Java_sun_awt_motif_MEmbedCanvasPeer_isXEmbedActive(env, this)) { |
| Atom actual_type; |
| int actual_format; |
| unsigned long nitems; |
| unsigned long bytes_after; |
| CARD32 * data = NULL; |
| DASSERT(sdata->handle != None); |
| if (XGetWindowProperty(awt_display, sdata->handle, XA_XEmbedInfo, |
| 0, 2, False, XA_XEmbedInfo, &actual_type, |
| &actual_format, &nitems, &bytes_after, |
| (unsigned char**)&data) != Success) |
| { |
| AWT_UNLOCK(); |
| return; |
| } |
| if (actual_type == XA_XEmbedInfo && actual_format == 32 |
| && nitems == 2) |
| { |
| CARD32 flags; |
| Boolean new_mapped, currently_mapped; |
| sdata->version = *data; |
| flags = *(data+1); |
| new_mapped = (flags & XEMBED_MAPPED) != 0; |
| currently_mapped = isMapped(sdata->handle); |
| if (new_mapped != currently_mapped) { |
| if (new_mapped) { |
| XMapWindow(awt_display, sdata->handle); |
| } else { |
| XUnmapWindow(awt_display, sdata->handle); |
| } |
| } |
| } |
| if (data != NULL) { |
| XFree(data); |
| } |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /** |
| * Handles client message on embedder |
| */ |
| static void |
| handleClientMessage(JNIEnv* env, jobject this, XClientMessageEvent * ev) { |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACEP5("handleClientMessage: 0=%ld 1=%ld 2=%ld 3=%ld 4=%ld\n", |
| ev->data.l[0], ev->data.l[1], ev->data.l[2], ev->data.l[3], ev->data.l[4]); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL && sdata->handle != None) { |
| switch ((int)ev->data.l[1]) { |
| case XEMBED_REQUEST_FOCUS: |
| MTRACE("REQUEST_FOCUS\n"); |
| (*env)->CallVoidMethod(env, this, requestXEmbedFocusMID); |
| break; |
| case XEMBED_FOCUS_NEXT: |
| MTRACE("FOCUS_NEXT\n"); |
| (*env)->CallVoidMethod(env, this, focusNextMID); |
| break; |
| case XEMBED_FOCUS_PREV: |
| MTRACE("FOCUS_PREV\n"); |
| (*env)->CallVoidMethod(env, this, focusPrevMID); |
| break; |
| case XEMBED_REGISTER_ACCELERATOR: |
| MTRACE("REGISTER_ACCEL\n"); |
| (*env)->CallVoidMethod(env, this, registerAcceleratorMID, |
| (jlong)ev->data.l[2], |
| (jlong)ev->data.l[3], |
| (jlong)ev->data.l[4]); |
| break; |
| case XEMBED_UNREGISTER_ACCELERATOR: |
| MTRACE("UNREGISTER_ACCEL\n"); |
| (*env)->CallVoidMethod(env, this, unregisterAcceleratorMID, |
| (jlong)ev->data.l[2]); |
| break; |
| case NON_STANDARD_XEMBED_GTK_GRAB_KEY: |
| MTRACE("GRAB_KEY\n"); |
| (*env)->CallVoidMethod(env, this, grabKeyMID, |
| (jlong)ev->data.l[3], |
| (jlong)ev->data.l[4]); |
| break; |
| case NON_STANDARD_XEMBED_GTK_UNGRAB_KEY: |
| MTRACE("UNGRAB_KEY\n"); |
| (*env)->CallVoidMethod(env, this, ungrabKeyMID, |
| (jlong)ev->data.l[3], |
| (jlong)ev->data.l[4]); |
| case _SUN_XEMBED_START: |
| MTRACE("XEMBED_START\n"); |
| processXEmbedInfo(env, this); |
| Java_sun_awt_motif_MEmbedCanvasPeer_notifyChildEmbedded(env, this); |
| break; |
| } |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /** |
| * Handles property changes on xembed client |
| */ |
| static void |
| handlePropertyNotify(XPropertyEvent * ev) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("handlePropertyNotify\n"); |
| sdata = getData(ev->window); |
| if (sdata != NULL) { |
| if (ev->atom == XA_WM_NORMAL_HINTS) { |
| DASSERT(sdata->server != NULL); |
| (*env)->CallVoidMethod(env, sdata->server, childResizedMID); |
| MTRACE("NORMAL_HINTS have changed\n"); |
| } else if (ev->atom == XA_XdndAware) { |
| unregister_xembed_drop_site(env, awt_display, sdata->server, |
| sdata->serverHandle, sdata->handle); |
| if (ev->state == PropertyNewValue) { |
| register_xembed_drop_site(env, awt_display, sdata->server, |
| sdata->serverHandle, sdata->handle); |
| } |
| } else if (ev->atom == XA_XEmbedInfo) { |
| DASSERT(sdata->server != NULL); |
| MTRACE("XEMBED_INFO has changed\n"); |
| processXEmbedInfo(env, sdata->server); |
| } |
| } |
| AWT_UNLOCK(); |
| } |
| |
| static void |
| handleConfigureNotify(XConfigureEvent * ev) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| MTRACE("handleConfigureNotify\n"); |
| sdata = getData(ev->window); |
| if (sdata != NULL) { |
| DASSERT(sdata->server != NULL); |
| (*env)->CallVoidMethod(env, sdata->server, childResizedMID); |
| } |
| AWT_UNLOCK(); |
| } |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: sendMessage |
| * Signature: (IJJJ)V |
| */ |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_GrabbedKey_initKeySymAndModifiers (JNIEnv *env, jobject this, jobject keyevent) { |
| jbyteArray array; |
| XEvent *xevent; |
| int keysym, modifiers; |
| int keycode; |
| AWT_LOCK(); |
| array = (jbyteArray)(*env)->GetObjectField(env, keyevent, awtEventIDs.bdata); |
| if (array == NULL) { |
| AWT_UNLOCK(); |
| return; |
| } |
| xevent = (XEvent *)(*env)->GetByteArrayElements(env, array, NULL); |
| if (xevent == NULL) { |
| (*env)->DeleteLocalRef(env, array); |
| AWT_UNLOCK(); |
| return; |
| } |
| keycode = (*env)->GetIntField(env, keyevent, keyEventIDs.keyCode); |
| keysym = awt_getX11KeySym(keycode); |
| modifiers = xevent->xkey.state; |
| (*env)->SetLongField(env, this, keysymFID, (jlong)keysym); |
| (*env)->SetLongField(env, this, modifiersFID, (jlong)modifiers); |
| (*env)->DeleteLocalRef(env, array); |
| AWT_UNLOCK(); |
| } |
| |
| #ifdef __linux__ |
| void |
| print_stack (void) |
| { |
| void *array[10]; |
| size_t size; |
| char **strings; |
| size_t i; |
| |
| size = backtrace (array, 10); |
| strings = backtrace_symbols (array, size); |
| |
| fprintf (stderr, "Obtained %zd stack frames.\n", size); |
| |
| for (i = 0; i < size; i++) |
| fprintf (stderr, "%s\n", strings[i]); |
| |
| free (strings); |
| } |
| #endif |
| |
| extern int32_t numEventsHandled; |
| |
| XCreateWindowEvent cr; |
| |
| void |
| dispatchEmbedderEvent(jobject server, XEvent * ev) { |
| JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2); |
| DASSERT(server != NULL); |
| DASSERT(ev != NULL); |
| AWT_LOCK(); |
| /* MTRACE("dispatchEmebddedEvent\n"); */ |
| switch (ev->type) { |
| case CreateNotify: |
| |
| MTRACEP3("CreateNotify for %x, serial %d, num events %d\n", (ev->xcreatewindow.window), (ev->xany.serial), (numEventsHandled)); |
| Java_sun_awt_motif_MEmbedCanvasPeer_embedChild(env, server, ev->xcreatewindow.window); |
| break; |
| case DestroyNotify: |
| MTRACE("DestroyNotify\n"); |
| Java_sun_awt_motif_MEmbedCanvasPeer_childDestroyed(env, server); |
| break; |
| case ReparentNotify: |
| MTRACEP2("ReparentNotify for %x, parent %x\n", (ev->xreparent.window), (ev->xreparent.parent)); |
| Java_sun_awt_motif_MEmbedCanvasPeer_embedChild(env, server, ev->xreparent.window); |
| break; |
| case ClientMessage: |
| MTRACE("ClientMessage\n"); |
| handleClientMessage(env, server, &ev->xclient); |
| break; |
| } |
| AWT_UNLOCK(); |
| } |
| |
| void |
| dispatchEmbeddingClientEvent(XEvent * ev) { |
| DASSERT(ev != NULL); |
| MTRACE("dispatchEmbeddingClientEvent\n"); |
| switch (ev->type) { |
| case PropertyNotify: |
| handlePropertyNotify(&ev->xproperty); |
| break; |
| case ConfigureNotify: |
| handleConfigureNotify(&ev->xconfigure); |
| break; |
| } |
| } |
| |
| void |
| xembed_serverEventHandler(XEvent * ev) { |
| pxembed_server_data sdata; |
| sdata = getData(ev->xany.window); |
| if (sdata != NULL) { // Event on client |
| dispatchEmbeddingClientEvent(ev); |
| } else { |
| sdata = getDataByServerHandle(ev->xany.window); |
| if (sdata != NULL) { |
| DASSERT(sdata->server != NULL); |
| dispatchEmbedderEvent(sdata->server, ev); |
| } |
| } |
| } |
| |
| /**************************** XEmbed server DnD support ***********************/ |
| void |
| set_xembed_drop_target(JNIEnv* env, jobject server) { |
| |
| (*env)->CallVoidMethod(env, server, setXEmbedDropTargetMID); |
| } |
| |
| void |
| remove_xembed_drop_target(JNIEnv* env, jobject server) { |
| (*env)->CallVoidMethod(env, server, removeXEmbedDropTargetMID); |
| } |
| |
| Boolean |
| is_xembed_client(Window window) { |
| return getData(window) != NULL; |
| } |
| /******************************************************************************/ |
| |
| /* |
| * Class: sun_awt_motif_MEmbedCanvasPeer |
| * Method: getWindow |
| * Signature: ()V |
| */ |
| JNIEXPORT jlong JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_getWindow(JNIEnv *env, jobject this) { |
| struct ComponentData *cdata; |
| Window res = None; |
| AWT_LOCK(); |
| cdata = (struct ComponentData *) |
| JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData); |
| DASSERT(cdata != NULL); |
| res = XtWindow(cdata->widget); |
| AWT_UNLOCK(); |
| return (jlong)res; |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_sun_awt_motif_MEmbedCanvasPeer_forwardEventToEmbedded(JNIEnv *env, |
| jobject this, |
| jlong ctxt, |
| jint eventID){ |
| pxembed_server_data sdata; |
| AWT_LOCK(); |
| sdata = getDataByEmbedder(this); |
| if (sdata != NULL) { |
| forward_event_to_embedded(sdata->handle, ctxt, eventID); |
| } |
| AWT_UNLOCK(); |
| } |
