1 /*

     2  * Copyright 1999-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 #ifdef HEADLESS

    27     #error This file should not be included in headless library

    28 #endif

    29 

    30 #include "awt_p.h"

    31 

    32 #include <X11/Shell.h>

    33 #include <Xm/VendorS.h>

    34 #include <Xm/Form.h>

    35 #include <Xm/DialogS.h>

    36 #include <Xm/AtomMgr.h>

    37 #include <Xm/Protocols.h>

    38 #include <Xm/MenuShell.h>

    39 #include <Xm/MwmUtil.h>

    40 #include "VDrawingArea.h"

    41 

    42 #ifdef DEBUG

    43 #  include <X11/Xmu/Editres.h>

    44 #endif

    45 

    46 #include <jni.h>

    47 #include <jni_util.h>

    48 

    49 /* JNI headers */

    50 #include "java_awt_Color.h"

    51 #include "java_awt_Component.h"

    52 #include "java_awt_Dialog.h"

    53 #include "java_awt_Font.h"

    54 #include "java_awt_Frame.h"

    55 #include "java_awt_Image.h"

    56 #include "java_awt_Insets.h"

    57 #include "java_awt_Insets.h"

    58 #include "java_awt_MenuBar.h"

    59 #include "java_awt_Window.h"

    60 #include "java_awt_event_FocusEvent.h"

    61 #include "java_awt_TrayIcon.h"

    62 #include "sun_awt_EmbeddedFrame.h"

    63 #include "sun_awt_motif_MComponentPeer.h"

    64 #include "sun_awt_motif_MDialogPeer.h"

    65 #include "sun_awt_motif_MEmbeddedFramePeer.h"

    66 #include "sun_awt_motif_MFramePeer.h"

    67 #include "sun_awt_motif_MMenuBarPeer.h"

    68 #include "sun_awt_motif_MWindowPeer.h"

    69 

    70 /* JNI field and method ids */

    71 #include "awt_Component.h"

    72 #include "awt_GraphicsEnv.h"

    73 #include "awt_Insets.h"

    74 #include "awt_MenuBar.h"

    75 #include "awt_Window.h"

    76 #include "awt_KeyboardFocusManager.h"

    77 #include "awt_MToolkit.h"

    78 #include "awt_Plugin.h"

    79 

    80 #include "color.h"

    81 #include "canvas.h"

    82 #include "awt_util.h"

    83 #include "img_util.h"

    84 #include "awt_wm.h"

    85 #include "awt_util.h"

    86 #include "awt_xembed.h"

    87 

    88 

    89 #ifdef __linux__

    90 void adjustStatusWindow(Widget shell);

    91 #endif

    92 /* For the moment only InputMethodWindow is taking advantage of

    93 ** the posibility for different decor styles

    94 ** values could be passed are the MWM_DECOR defines

    95 ** for the moment we are full on or full off.

    96 */

    97 #define AWT_NO_DECOR    0x0

    98 #define AWT_FULL_DECOR  MWM_DECOR_ALL

    99 

   100 static void reshape(JNIEnv *env, jobject this, struct FrameData *wdata,

   101                     jint x, jint y, jint w, jint h, Boolean setXY);

   102 Widget findTopLevelByShell(Widget widget);

   103 

   104 extern EmbeddedFrame *theEmbeddedFrameList;

   105 extern struct ComponentIDs componentIDs;

   106 extern struct MMenuBarPeerIDs mMenuBarPeerIDs;

   107 extern struct MComponentPeerIDs mComponentPeerIDs;

   108 struct WindowIDs windowIDs;

   109 struct MWindowPeerIDs mWindowPeerIDs;

   110 extern struct InsetsIDs insetsIDs;

   111 extern struct X11GraphicsConfigIDs x11GraphicsConfigIDs;

   112 extern struct KeyboardFocusManagerIDs keyboardFocusManagerIDs;

   113 extern struct X11GraphicsDeviceIDs x11GraphicsDeviceIDs;

   114 

   115 #ifndef NOMODALFIX

   116 extern Boolean awt_isModal();

   117 extern Boolean awt_isWidgetModal(Widget w);

   118 extern void awt_shellPoppedUp(Widget shell, XtPointer c, XtPointer d);

   119 extern void awt_shellPoppedDown(Widget shell, XtPointer c, XtPointer d);

   120 #endif //NOMODALFIX

   121 

   122 static jclass inputMethodWindowClass = NULL;

   123 

   124 static int32_t globalTopGuess    = 0;

   125 static int32_t globalLeftGuess   = 0;

   126 static int32_t globalBottomGuess = 0;

   127 static int32_t globalRightGuess  = 0;

   128 

   129 

   130 // Atom used for otlogenniy top-level disposal

   131 static Atom _XA_JAVA_DISPOSE_PROPERTY_ATOM = 0;

   132 

   133 /*

   134  * Fix for bug 4141361

   135  *

   136  * We keep a linked list of the FrameData information for

   137  * every top level window.

   138  */

   139 struct FrameDataList {

   140     struct FrameData* wdata;

   141     struct FrameDataList* next;

   142 };

   143 

   144 static struct FrameDataList* allTopLevel = NULL;

   145 

   146 extern void checkNewXineramaScreen(JNIEnv* env, jobject peer,

   147                                    struct FrameData* wdata,

   148                                    int32_t newX, int32_t newY,

   149                                    int32_t newWidth, int32_t newHeight);

   150 

   151 // Returns false if this Window is non-focusable

   152 // or its nearest decorated parent is non-focusable.

   153 Boolean isFocusableWindowByPeer(JNIEnv * env, jobject peer) {

   154     jobject target, decoratedParent;

   155     struct FrameData *wdata;

   156     Boolean focusable;

   157 

   158     wdata = (struct FrameData *)JNU_GetLongFieldAsPtr(env, peer, mComponentPeerIDs.pData);

   159     DASSERT(wdata != NULL);

   160 

   161     target = (*env)->GetObjectField(env, peer, mComponentPeerIDs.target);

   162     DASSERT(target != NULL);

   163 

   164     decoratedParent = getOwningFrameOrDialog(target, env);

   165     (*env)->DeleteLocalRef(env, target);

   166 

   167     if (decoratedParent == NULL) {

   168         return wdata->isFocusableWindow;

   169     } else {

   170         jobject parentPeer = (*env)->GetObjectField(env, decoratedParent, componentIDs.peer);

   171         DASSERT(parentPeer != NULL);

   172         focusable = wdata->isFocusableWindow && isFocusableWindowByPeer(env, parentPeer);

   173 

   174         (*env)->DeleteLocalRef(env, decoratedParent);

   175         (*env)->DeleteLocalRef(env, parentPeer);

   176     }

   177     return focusable;

   178 }

   179 

   180 // Returns false if this shell's Java Window is non-focusable

   181 // or its nearest decorated parent is non-focusable.

   182 // Returns true otherwise or if any of parameters is NULL

   183 Boolean isFocusableWindowByShell(JNIEnv* env, Widget shell) {

   184     Widget toplevel;

   185     jobject peer;

   186     Boolean focusable;

   187 

   188     DASSERT(shell != NULL && XtIsShell(shell));

   189     if (shell == NULL) return True;

   190     if (!XtIsShell(shell)) return True;

   191 

   192     toplevel = findTopLevelByShell(shell);

   193     if (toplevel == NULL) {

   194         return True;

   195     }

   196     peer = findPeer(&toplevel);

   197     DASSERT(peer != NULL);

   198 

   199     if (env == NULL) {

   200         env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   201     }

   202     return isFocusableWindowByPeer(env, peer);

   203 }

   204 

   205 

   206 // Returns Shell widget - the parent of this child

   207 Widget getShellWidget(Widget child) {

   208 

   209     while (child != NULL && !XtIsShell(child)) {

   210         child = XtParent(child);

   211     }

   212     return child;

   213 }

   214 

   215 // Returns false if the parent shell of this widget is non-focusable Java Window.

   216 // Returns false otherwise.

   217 // Doesn't accept NULL parameters.

   218 Boolean isFocusableComponentTopLevelByWidget(JNIEnv * env, Widget child) {

   219     Widget shell = NULL;

   220     shell = getShellWidget(child);

   221     DASSERT(shell);

   222     return isFocusableWindowByShell(env, shell);

   223 }

   224 

   225 

   226 /*

   227  * Add a new element into the top level window list

   228  */

   229 void addTopLevel(struct FrameData* wdata) {

   230     struct FrameDataList* newNode;

   231     newNode = (struct FrameDataList*)

   232         malloc(sizeof(struct FrameDataList));

   233     newNode->wdata = wdata;

   234     newNode->next = allTopLevel;

   235     allTopLevel = newNode;

   236 }

   237 

   238 /*

   239  * Remove an element from the top level window list

   240  * (recursive)

   241  */

   242 Boolean removeTopLevelR(struct FrameDataList** ptr,

   243     struct FrameData* wdata) {

   244     struct FrameDataList* node = *ptr;

   245     if (node == NULL) {

   246         return False;

   247     }

   248     if (node->wdata == wdata) {

   249         *ptr = node->next;

   250         free(node);

   251         return True;

   252     }

   253     return removeTopLevelR(&(node->next), wdata);

   254 }

   255 

   256 Boolean removeTopLevel(struct FrameData* wdata) {

   257     return removeTopLevelR(&allTopLevel, wdata);

   258 }

   259 

   260 /*

   261  * Return the Widget ID of the top level window underneath the

   262  * mouse pointer.

   263  */

   264 Widget awt_GetWidgetAtPointer() {

   265     struct FrameDataList* ptr = allTopLevel;

   266     Window rootWindow, childWindow, mainWindow;

   267     int32_t xw, yw, xr, yr;

   268     uint32_t keys;

   269     while (ptr != NULL) {

   270         mainWindow = XtWindow(ptr->wdata->mainWindow);

   271         XQueryPointer(awt_display, mainWindow,

   272             &rootWindow, &childWindow, &xr, &yr, &xw, &yw, &keys);

   273         if (childWindow != None) {

   274             return ptr->wdata->winData.comp.widget;

   275         }

   276         ptr = ptr->next;

   277     }

   278     return NULL;

   279 }

   280 

   281 Widget findFocusProxy(Widget widget) {

   282   struct FrameDataList* ptr = allTopLevel;

   283   for (ptr = allTopLevel; ptr != NULL; ptr = ptr->next) {

   284     if (ptr->wdata->winData.comp.widget == widget) {

   285       return ptr->wdata->focusProxy;

   286     }

   287   }

   288   return NULL;

   289 }

   290 

   291 Widget findTopLevelByShell(Widget widget) {

   292   struct FrameDataList* ptr;

   293   for (ptr = allTopLevel; ptr != NULL; ptr = ptr->next) {

   294       if (ptr->wdata->winData.shell == widget) {

   295           return ptr->wdata->winData.comp.widget;

   296       }

   297   }

   298   return NULL;

   299 }

   300 

   301 void

   302 awt_Frame_guessInsets(struct FrameData *wdata)

   303 {

   304     if (wdata->decor == AWT_NO_DECOR ) {

   305         wdata->top    = wdata->topGuess    = 0;

   306         wdata->left   = wdata->leftGuess   = 0;

   307         wdata->bottom = wdata->bottomGuess = 0;

   308         wdata->right  = wdata->rightGuess  = 0;

   309         return;

   310     }

   311 

   312     if (globalTopGuess == 0) {

   313         char *insets_env;

   314 

   315         if (wdata->top >= 0) {

   316             /* insets were set on wdata by System Properties */

   317             globalTopGuess    = wdata->top;

   318             globalLeftGuess   = wdata->left;

   319             globalBottomGuess = wdata->bottom;

   320             globalRightGuess  = wdata->right;

   321         }

   322         else switch (awt_wm_getRunningWM()) {

   323         case ENLIGHTEN_WM:

   324             globalTopGuess    = 19;

   325             globalLeftGuess   =  4;

   326             globalBottomGuess =  4;

   327             globalRightGuess  =  4;

   328             break;

   329 

   330         case CDE_WM:

   331             globalTopGuess    = 28;

   332             globalLeftGuess   =  6;

   333             globalBottomGuess =  6;

   334             globalRightGuess  =  6;

   335             break;

   336 

   337         case MOTIF_WM:

   338         case OPENLOOK_WM:

   339         default:

   340             globalTopGuess    = 25;

   341             globalLeftGuess   =  5;

   342             globalBottomGuess =  5;

   343             globalRightGuess  =  5;

   344             break;

   345         }

   346 

   347         if ((insets_env = getenv("AWT_INSETS")) != NULL) {

   348             int guess = atoi(insets_env);

   349             globalTopGuess    = (guess & 0xff00) >> 8;

   350             globalLeftGuess   = guess & 0x00ff;

   351             globalBottomGuess = wdata->leftGuess;

   352             globalRightGuess  = wdata->leftGuess;

   353         }

   354 

   355         /* don't allow bizarly large insets */

   356         if ((globalTopGuess > 64) || (globalTopGuess < 0))

   357             globalTopGuess = 28;

   358         if ((globalLeftGuess > 32) || (globalLeftGuess < 0))

   359             globalLeftGuess = 6;

   360         if ((globalBottomGuess > 32) || (globalBottomGuess < 0))

   361             globalBottomGuess = 6;

   362         if ((globalRightGuess > 32) || (globalRightGuess < 0))

   363             globalRightGuess = 6;

   364     }

   365 

   366     wdata->top    = wdata->topGuess    = globalTopGuess;

   367     wdata->left   = wdata->leftGuess   = globalLeftGuess;

   368     wdata->bottom = wdata->bottomGuess = globalBottomGuess;

   369     wdata->right  = wdata->rightGuess  = globalRightGuess;

   370 }

   371 

   372 /*

   373  * To keep input method windows floating, maintain a list of all

   374  * input method windows here.  When some top level window gets

   375  * activated, moved, or resized, these input method windows need

   376  * to be brought on top.

   377  */

   378 static struct FrameDataList* allInputMethodWindow = NULL;

   379 

   380 /*

   381  * Add a new element into the input method window list

   382  */

   383 void addInputMethodWindow(struct FrameData* wdata) {

   384     struct FrameDataList* newNode;

   385     newNode = (struct FrameDataList*)

   386         malloc(sizeof(struct FrameDataList));

   387     newNode->wdata = wdata;

   388     newNode->next = allInputMethodWindow;

   389     allInputMethodWindow = newNode;

   390 }

   391 

   392 /*

   393  * Remove an element from the top level window list

   394  * (recursive)

   395  */

   396 Boolean removeInputMethodWindowR(struct FrameDataList** ptr,

   397     struct FrameData* wdata) {

   398     struct FrameDataList* node = *ptr;

   399     if (node == NULL) {

   400         return False;

   401     }

   402     if (node->wdata == wdata) {

   403         *ptr = node->next;

   404         free(node);

   405         return True;

   406     }

   407     return removeInputMethodWindowR(&(node->next), wdata);

   408 }

   409 

   410 Boolean removeInputMethodWindow(struct FrameData* wdata) {

   411     return removeInputMethodWindowR(&allInputMethodWindow, wdata);

   412 }

   413 

   414 /*

   415  * Raise input method windows

   416  */

   417 void raiseInputMethodWindow(struct FrameData* wdata) {

   418     struct FrameDataList* node = allInputMethodWindow;

   419 

   420     if (wdata->isInputMethodWindow) {

   421         return;

   422     }

   423 

   424     while (node != NULL) {

   425         XRaiseWindow(awt_display, XtWindow(node->wdata->winData.shell));

   426         node = node->next;

   427     }

   428 }

   429 

   430 /* fieldIDs for Frame fields that may be accessed from C */

   431 static struct FrameIDs {

   432     jfieldID resizable;

   433     jfieldID state;

   434 } frameIDs;

   435 

   436 /*

   437  * Class:     java_awt_Frame

   438  * Method:    initIDs

   439  * Signature: ()V

   440  */

   441 

   442 /* This function gets called from the static initializer for Frame.java

   443    to initialize the fieldIDs for fields that may be accessed from C */

   444 JNIEXPORT void JNICALL

   445 Java_java_awt_Frame_initIDs

   446   (JNIEnv *env, jclass cls)

   447 {

   448     frameIDs.resizable = (*env)->GetFieldID(env, cls, "resizable", "Z");

   449     frameIDs.state = (*env)->GetFieldID(env, cls, "state", "I");

   450 }

   451 

   452 /* ******* */

   453 /* Dialogs */

   454 /* ******* */

   455 /* No longer have a need for unique fields for query */

   456 static struct DialogIDs {

   457     jfieldID modal;

   458     jfieldID resizable;

   459 } dialogIDs;

   460 

   461 JNIEXPORT void JNICALL

   462 Java_java_awt_Dialog_initIDs

   463   (JNIEnv *env, jclass cls)

   464 {

   465 #if 0

   466     dialogIDs.modal = (*env)->GetFieldID(env, cls, "modal", "Z");

   467     dialogIDs.resizable = (*env)->GetFieldID(env, cls, "resizable", "Z");

   468 #endif

   469 }

   470 

   471 /* ******* */

   472 /* Windows */

   473 /* ******* */

   474 

   475 JNIEXPORT void JNICALL

   476 Java_java_awt_Window_initIDs

   477   (JNIEnv *env, jclass cls)

   478 {

   479     windowIDs.warningString = (*env)->GetFieldID(env, cls, "warningString",

   480                                                  "Ljava/lang/String;");

   481     windowIDs.resetGCMID = (*env)->GetMethodID(env, cls, "resetGC",

   482                                                  "()V");

   483 

   484     windowIDs.locationByPlatform = (*env)->GetFieldID(env, cls, "locationByPlatform",

   485                                                         "Z");

   486     windowIDs.isAutoRequestFocus = (*env)->GetFieldID(env, cls, "autoRequestFocus", "Z");

   487 

   488     DASSERT(windowIDs.resetGCMID);

   489 }

   490 

   491 /*

   492  * Class:     sun_motif_awt_WindowAttributes

   493  * Method:    initIDs

   494  * Signature: ()V

   495  */

   496 

   497 static struct MWindowAttributeIDs {

   498     jfieldID nativeDecor;

   499     jfieldID initialFocus;

   500     jfieldID isResizable;

   501     jfieldID initialState;

   502     jfieldID visibilityState;

   503     jfieldID decorations;

   504 } mWindowAttributeIDs;

   505 

   506 JNIEXPORT void JNICALL

   507 Java_sun_awt_motif_MWindowAttributes_initIDs

   508   (JNIEnv *env, jclass cls)

   509 {

   510     mWindowAttributeIDs.nativeDecor =

   511         (*env)->GetFieldID(env, cls, "nativeDecor", "Z");

   512     mWindowAttributeIDs.initialFocus =

   513         (*env)->GetFieldID(env, cls, "initialFocus", "Z");

   514     mWindowAttributeIDs.isResizable =

   515         (*env)->GetFieldID(env, cls, "isResizable", "Z");

   516     mWindowAttributeIDs.initialState =

   517         (*env)->GetFieldID(env, cls, "initialState", "I");

   518     mWindowAttributeIDs.visibilityState =

   519         (*env)->GetFieldID(env, cls, "visibilityState", "I");

   520     mWindowAttributeIDs.decorations =

   521         (*env)->GetFieldID(env, cls, "decorations", "I");

   522 }

   523 

   524 /*

   525  * Class:     sun_awt_motif_MWindowPeer

   526  * Method:    initIDs

   527  * Signature: ()V

   528  */

   529 

   530 /* This function gets called from the static initializer for MWindowPeer.java

   531    to initialize the fieldIDs for fields that may be accessed from C */

   532 

   533 JNIEXPORT void JNICALL

   534 Java_sun_awt_motif_MWindowPeer_initIDs

   535   (JNIEnv *env, jclass cls)

   536 {

   537     mWindowPeerIDs.insets =

   538         (*env)->GetFieldID(env, cls, "insets", "Ljava/awt/Insets;");

   539     mWindowPeerIDs.winAttr =

   540         (*env)->GetFieldID( env,

   541                             cls,

   542                             "winAttr",

   543                             "Lsun/awt/motif/MWindowAttributes;"

   544                           );

   545     mWindowPeerIDs.iconWidth =

   546         (*env)->GetFieldID(env, cls, "iconWidth", "I");

   547     mWindowPeerIDs.iconHeight =

   548         (*env)->GetFieldID(env, cls, "iconHeight", "I");

   549     mWindowPeerIDs.handleWindowFocusOut =

   550         (*env)->GetMethodID(env,

   551                             cls,

   552                             "handleWindowFocusOut",

   553                             "(Ljava/awt/Window;)V");

   554     mWindowPeerIDs.handleWindowFocusIn =

   555         (*env)->GetMethodID(env,

   556                             cls,

   557                             "handleWindowFocusIn",

   558                             "()V");

   559     mWindowPeerIDs.handleIconify =

   560         (*env)->GetMethodID(env,

   561                             cls,

   562                             "handleIconify",

   563                             "()V");

   564     mWindowPeerIDs.handleDeiconify =

   565         (*env)->GetMethodID(env,

   566                             cls,

   567                             "handleDeiconify",

   568                             "()V");

   569     mWindowPeerIDs.handleStateChange =

   570         (*env)->GetMethodID(env,

   571                             cls,

   572                             "handleStateChange",

   573                             "(II)V");

   574 

   575     mWindowPeerIDs.draggedToScreenMID = (*env)->GetMethodID(env, cls,

   576                                                            "draggedToNewScreen",

   577                                                            "(I)V");

   578     DASSERT(mWindowPeerIDs.draggedToScreenMID);

   579 }

   580 

   581 /*

   582  * Class:     sun_awt_motif_MWindowPeer

   583  * Method:    wrapInSequenced

   584  * Signature: (Ljava/awt/AWTEvent;)Ljava/awt/SequencedEvent;

   585  */

   586 

   587 /* This method gets called from MWindowPeer to wrap a FocusEvent in

   588    a SequencedEvent. We have to do this in native code, because we

   589    don't want to make SequencedEvent a public class. */

   590 

   591 JNIEXPORT jobject JNICALL

   592 Java_sun_awt_motif_MWindowPeer_wrapInSequenced

   593   (JNIEnv *env, jobject this, jobject awtevent)

   594 {

   595   jobject global = awt_canvas_wrapInSequenced(awtevent);

   596   jobject local = (*env)->NewLocalRef(env, global);

   597   (*env)->DeleteGlobalRef(env, global);

   598   return local;

   599 }

   600 

   601 extern jobject findTopLevelOpposite();

   602 

   603 /*

   604  * Class:     sun_awt_motif_MWindowPeer

   605  * Method:    findOpposite

   606  * Signature: (Ljava/awt/AWTEvent;)Ljava/awt/Window;

   607  */

   608 

   609 JNIEXPORT jobject JNICALL

   610 Java_sun_awt_motif_MWindowPeer_findOpposite

   611     (JNIEnv *env, jobject this, jint eventType)

   612 {

   613 #ifdef HEADLESS

   614     return NULL;

   615 #else

   616     if ((*env)->EnsureLocalCapacity(env, 1) < 0) {

   617         return NULL;

   618     }

   619 

   620     return findTopLevelOpposite(env, eventType);

   621 #endif

   622 }

   623 

   624 /* changeInsets() sets target's insets equal to X/Motif values. */

   625 

   626 static void

   627 awtJNI_ChangeInsets(JNIEnv * env, jobject this, struct FrameData *wdata)

   628 {

   629     jobject insets;

   630 

   631     if ((*env)->EnsureLocalCapacity(env, 1) < 0)

   632         return;

   633 

   634     insets = (*env)->GetObjectField(env, this, mWindowPeerIDs.insets);

   635 

   636     if (JNU_IsNull(env, insets)) {

   637         return;

   638     }

   639 

   640     (*env)->SetIntField(env, insets, insetsIDs.top, wdata->top);

   641     (*env)->SetIntField(env, insets, insetsIDs.left, wdata->left);

   642     (*env)->SetIntField(env, insets, insetsIDs.bottom, wdata->bottom);

   643     (*env)->SetIntField(env, insets, insetsIDs.right, wdata->right);

   644 

   645     /* Fix for 4106068: don't do it, rely on the window */

   646     /*   manager maximizing policy instead              */

   647 #if 0

   648     /* when the insets get set, make sure we set the proper */

   649     /* max window size (since it's dependent on inset size) */

   650     if (wdata->isResizable) {

   651         int32_t screenWidth = XWidthOfScreen( XDefaultScreenOfDisplay(awt_display));

   652         int32_t screenHeight= XHeightOfScreen(XDefaultScreenOfDisplay(awt_display));

   653         XtVaSetValues(wdata->winData.shell,

   654                 XmNmaxWidth, screenWidth - (wdata->left + wdata->right),

   655                 XmNmaxHeight, screenHeight - (wdata->top + wdata->bottom),

   656                 NULL);

   657     }

   658 #endif

   659     (*env)->DeleteLocalRef(env, insets);

   660 }

   661 

   662 

   663 /* setMbAndWwHeightAndOffsets() attempts to establish the heights

   664    of frame's menu bar and warning window (if present in frame).

   665    setMbAndWwHeightAndOffsets() also adjusts appropriately the

   666    X/Motif offsets and calls changeInsets() to set target insets.

   667    A warning window, if present, is established during ...create().

   668    wdata->warningWindow is set there, wdata->wwHeight is set here.

   669    Routine pSetMenuBar() sets value of the wdata->menuBar field.

   670    This routine reads that value. If it is not null, a menubar

   671    has been added.  In this case, calculate the current height

   672    of the menu bar.  This may be a partial (incomplete) menubar

   673    because ths routine may be called before the X/Motif menubar

   674    is completely realized. In this case, the menubar height may

   675    be adjusted incrementally.  This routine may be called from

   676    ...pSetMenuBar(), innerCanvasEH(), and ...pReshape(). It is

   677    designed to (eventually) obtain the correct menubar height.

   678    On the other hand, if wdata->menuBar is NULL and the stored

   679    menubar height is not zero, then we subtract off the height. */

   680 

   681 static void

   682 awtJNI_setMbAndWwHeightAndOffsets(JNIEnv * env,

   683                                   jobject this,

   684                                   struct FrameData *wdata )

   685 {

   686     Dimension   warningHeight,  /* Motif warning window height  */

   687                 labelHeight;    /* Motif warning label's height */

   688 

   689     WidgetList  warningChildrenWL; /* warning children widgets  */

   690 

   691     Dimension   menuBarWidth,   /* Motif menubar width          */

   692                 menuBarHeight,  /* Motif menubar height         */

   693                 menuBarBorderSize, /* Motif menubar border size */

   694                 marginHeight,   /* Motif menubar margin height  */

   695                 menuHeight,     /* Motif menubar's menu height  */

   696                 menuBorderSize, /* Motif menu border size       */

   697                 actualHeight;   /* height: menu+margins+borders */

   698 

   699     WidgetList  menuBarChildrenWL; /* menubar children widgets  */

   700     Cardinal    numberChildren; /* number of menubar children   */

   701 

   702 #ifdef _pauly_debug

   703     fprintf(stdout," ++ setMenuBar\n");

   704     fflush(stdout);

   705 #endif /* _pauly_debug */

   706 

   707     /* If warning window height not yet known, try to get it now.

   708        It will be added to top or bottom (iff NETSCAPE) offset. */

   709     if  (wdata->warningWindow != NULL) {

   710         XtVaGetValues(wdata->warningWindow,

   711                       XmNheight, &warningHeight,

   712                       XmNchildren, &warningChildrenWL,

   713                       XmNnumChildren, &numberChildren,

   714                       NULL);

   715 

   716         /* We may be doing this before warning window is realized ! So,

   717            check for a child label in the warning. If its height is not

   718            yet accounted for in the warning height, then use it here.   */

   719         if  (numberChildren != 0) {

   720             XtVaGetValues(warningChildrenWL[0],

   721                           XmNheight, &labelHeight,

   722                           NULL);

   723 #ifdef _pauly_debug

   724             fprintf(stdout,"    setMenuBar.... warning label found with height: %d\n", labelHeight);

   725             fflush(stdout);

   726 #endif /* _pauly_debug */

   727             if  (warningHeight < labelHeight) {

   728 #ifdef _pauly_debug

   729     fprintf(stdout,"    setMenuBar.... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

   730     fflush(stdout);

   731 #endif /* _pauly_debug */

   732                 warningHeight = labelHeight;

   733             }

   734         }

   735 

   736         if  (wdata->wwHeight < warningHeight) {

   737 #ifdef _pauly_debug

   738             fprintf(stdout, "    setMenuBar.... adding warning height: %d\n", warningHeight);

   739             fflush(stdout);

   740 #endif /* _pauly_debug */

   741 #ifdef NETSCAPE

   742             wdata->bottom += (warningHeight - wdata->wwHeight);

   743 #else

   744             wdata->top += (warningHeight - wdata->wwHeight);

   745 #endif /* NETSCAPE */

   746             awtJNI_ChangeInsets(env, this, wdata);

   747             wdata->wwHeight = warningHeight;

   748         }

   749     }

   750 

   751     /* Now we adjust offsets for an added or removed menu bar   */

   752     if  (wdata->menuBar != NULL) {

   753 #ifdef _pauly_debug

   754         fprintf(stdout,"    setMenuBar.  menu bar: %x\n", wdata->menuBar);

   755         fflush(stdout);

   756 #endif /* _pauly_debug */

   757         XtVaGetValues(wdata->menuBar,

   758                       XmNwidth, &menuBarWidth,

   759                       XmNheight, &menuBarHeight,

   760                       XmNchildren, &menuBarChildrenWL,

   761                       XmNnumChildren, &numberChildren,

   762                       XmNborderWidth, &menuBarBorderSize,

   763                       XmNmarginHeight, &marginHeight,

   764                       NULL);

   765 

   766         /* We may be doing this before menu bar is realized ! Hence,

   767            check for a menu in the menu bar. If its height is not yet

   768            accounted for in the menu bar height, then add it in here.   */

   769         if  (numberChildren != 0) {

   770             XtVaGetValues(menuBarChildrenWL[0],

   771                           XmNheight, &menuHeight,

   772                           XmNborderWidth, &menuBorderSize,

   773                           NULL);

   774 #ifdef _pauly_debug

   775             fprintf(stdout,"    setMenuBar.... menu found with height: %d, border: %d, margin: %d, bar border: %d\n", menuHeight, menuBorderSize, marginHeight, menuBarBorderSize);

   776             fflush(stdout);

   777 #endif /* _pauly_debug */

   778             /* Calculate real height of menu bar by adding height of its

   779                child menu and borders, margins, and the menu bar borders*/

   780             actualHeight = menuHeight + (2 * menuBorderSize) +

   781                            (2 * marginHeight) + (2 * menuBarBorderSize);

   782 #ifdef __linux__

   783 #ifdef _pauly_debug

   784             fprintf(stdout,"  actual height: %d mb height %d\n", actualHeight, menuBarHeight);

   785             fflush(stdout);

   786 #endif /* _pauly_debug */

   787 #endif

   788             if  (menuBarHeight < actualHeight) {

   789 #ifdef _pauly_debug

   790 fprintf(stdout,"    setMenuBar.... ****************************************\n");

   791 fflush(stdout);

   792 #endif /* _pauly_debug */

   793                 menuBarHeight = actualHeight;

   794             }

   795         }

   796 

   797         if  (wdata->mbHeight < menuBarHeight) {

   798             /* Adjust the (partially) added menu bar height, top offset.*/

   799 #ifdef _pauly_debug

   800             fprintf(stdout, "    setMenuBar.... added menuBar height: %d\n", menuBarHeight);

   801             fflush(stdout);

   802 #endif /* _pauly_debug */

   803             wdata->top += (menuBarHeight - wdata->mbHeight);

   804             awtJNI_ChangeInsets(env, this, wdata);

   805             wdata->mbHeight = menuBarHeight;

   806         }

   807     } else if  ((wdata->menuBar == NULL) && (wdata->mbHeight > 0)) {

   808         /* A menu bar has been removed; subtract height from top offset.*/

   809         wdata->top -= wdata->mbHeight;

   810 #ifdef _pauly_debug

   811         fprintf(stdout, "    setMenuBar.... removed menuBar height: %d\n", wdata->mbHeight);

   812         fflush(stdout);

   813 #endif /* _pauly_debug */

   814         awtJNI_ChangeInsets(env, this, wdata);

   815         wdata->mbHeight = 0;

   816     }

   817 }

   818 

   819 

   820 /* outerCanvasResizeCB() is Motif resize callback for outer/child canvas.

   821    It reads width, height of Motif widget, sets java target accordingly,

   822    and then calls handleResize() to affect any changes.

   823    This call is only done for a shell resize or inner/parent resize;

   824    i.e., it may not be done for a ...pReshape() to avoid doing a loop.

   825 

   826    client_data is MWindowPeer instance

   827 */

   828 static void

   829 outerCanvasResizeCB(Widget wd, XtPointer client_data, XtPointer call_data)

   830 {

   831     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   832     jobject target;

   833     struct FrameData *wdata;

   834     Position    screenX;        /* x position of the canvas, screen */

   835     Position    screenY;        /* y position of the canvas, screen */

   836     Dimension   width;          /* width of the canvas, target  */

   837     Dimension   height;         /* height of the canvas, target */

   838     jint        oldWidth;

   839     jint        oldHeight;

   840 

   841 #ifdef _pauly_debug

   842     fprintf(stdout," ++ WindowResize.\n");

   843     fflush(stdout);

   844 #endif /* _pauly_debug */

   845 

   846     wdata = (struct FrameData *)

   847         JNU_GetLongFieldAsPtr(env, (jobject) client_data,

   848                               mComponentPeerIDs.pData);

   849     if (wdata == NULL) {

   850         return;

   851     }

   852 

   853     if ((*env)->EnsureLocalCapacity(env, 1) < 0)

   854         return;

   855 

   856     target = (*env)->GetObjectField(env, (jobject) client_data,

   857                                     mComponentPeerIDs.target);

   858     XtVaGetValues(wd,

   859                   XmNwidth, &width,

   860                   XmNheight, &height,

   861                   NULL);

   862 #ifdef _pauly_debug

   863     fprintf(stdout,"    outerCanvasResizeCB.  width: %d, height: %d\n", width, height);

   864     fflush(stdout);

   865 #endif /* _pauly_debug */

   866 

   867 

   868     XtTranslateCoords(wd, 0, 0, &screenX, &screenY);

   869 

   870     if  ((wdata->shellResized) || (wdata->canvasResized)) {

   871 #ifdef _pauly_debug

   872         fprintf(stdout,"    outerCanvasResizeCB\n");

   873         fflush(stdout);

   874 #endif /* _pauly_debug */

   875         wdata->shellResized = False;

   876         wdata->canvasResized = False;

   877         /*

   878         ** if you are not yet reparented, don't compute the size based on the

   879         ** widgets, as the window manager shell containg the insets is not yet

   880         ** there.  Use the size the application has set.

   881         ** If not reparented, we got here because the application set the size,

   882         ** so just send them Component.RESIZED event with the size they set.

   883         **

   884         ** If the reparenting causes a resize ( only when inset guess is wrong )        ** the new size will be sent in a Component.RESIZED event at that time.

   885         */

   886         if (wdata->reparented)

   887         {

   888             (*env)->SetIntField(env, target, componentIDs.x, (jint) screenX);

   889             (*env)->SetIntField(env, target, componentIDs.y, (jint) screenY);

   890         }

   891 

   892     oldWidth = (*env)->GetIntField(env, target, componentIDs.width);

   893     oldHeight = (*env)->GetIntField(env, target, componentIDs.height);

   894 

   895     if (oldWidth != width || oldHeight != height || wdata->need_reshape)

   896     {

   897         wdata->need_reshape = False;

   898         (*env)->SetIntField(env, target, componentIDs.width, (jint)width);

   899         (*env)->SetIntField(env, target, componentIDs.height,

   900                 (jint)height);

   901 

   902         /* only do this for Windows, not Canvases, btw */

   903         checkNewXineramaScreen(env, client_data, wdata, screenX, screenY, width, height);

   904 

   905         JNU_CallMethodByName(env, NULL, (jobject) client_data,

   906                  "handleResize", "(II)V", width, height);

   907         if  ((*env)->ExceptionOccurred(env)) {

   908             (*env)->ExceptionDescribe(env);

   909         (*env)->ExceptionClear(env);

   910         }

   911     }

   912     }

   913 

   914     (*env)->DeleteLocalRef(env, target);

   915 

   916 #ifdef _pauly_debug

   917     fprintf(stdout,"    WindowResize. Done.\n");

   918     fflush(stdout);

   919 #endif /* _pauly_debug */

   920 

   921 } /* outerCanvasResizeCB() */

   922 

   923 static void reconfigureOuterCanvas ( JNIEnv *env, jobject target,

   924                                      jobject this, struct FrameData *wdata )

   925 {

   926     Dimension   innerDAWidth,   /* width of inner Motif canvas  */

   927                 innerDAHeight,  /* height of inner Motif canvas */

   928                 outerDAWidth,   /* width of outer Motif canvas  */

   929                 outerDAHeight;  /* height of outer Motif canvas */

   930     int32_t     targetWidth,    /* java target object's width   */

   931                 targetHeight;   /* java target's object height  */

   932     Dimension   width;          /* width of the canvas, target  */

   933     Dimension   height;         /* height of the canvas, target */

   934 

   935 

   936     Position    innerX,         /* x loc. of inner Motif canvas */

   937                 innerY,         /* y loc. of inner Motif canvas */

   938                 x, y;

   939 

   940     /* canvasW is (visible) inner/parent drawing area (canvas) widget   */

   941     XtVaGetValues(XtParent(wdata->winData.comp.widget),

   942                   XmNwidth, &innerDAWidth,

   943                   XmNheight, &innerDAHeight,

   944                   XmNx, &innerX,

   945                   XmNy, &innerY,

   946                   NULL);

   947 

   948     /* This resize may be due to the insertion or removal of a menu bar.

   949        If so, we appropriately adjust the top offset in wdata, insets.  */

   950     awtJNI_setMbAndWwHeightAndOffsets(env, this, wdata);

   951 

   952     outerDAWidth = innerDAWidth + wdata->left + wdata->right;

   953     outerDAHeight = innerDAHeight + wdata->top + wdata->bottom;

   954 

   955     /* If it's a menu bar reset, do not do resize of outer/child canvas.

   956        (Another thread problem; we arrest this now before damage done.) */

   957     if  (wdata->menuBarReset)

   958     {

   959         targetWidth = (*env)->GetIntField(env, target, componentIDs.width);

   960         targetHeight = (*env)->GetIntField(env, target, componentIDs.height);

   961         if  ((outerDAWidth != targetWidth) || (outerDAHeight != targetHeight))

   962         {

   963             return;

   964         }

   965     }

   966 

   967     wdata->canvasResized = True;

   968 

   969     /* The outer/child drawing area (canvas) needs to be configured too.

   970        If its size changes, its resize callback will thereby be invoked.*/

   971     x = -wdata->left;

   972     y = -wdata->top;

   973     width = innerDAWidth + wdata->left + wdata->right;

   974     height = innerDAHeight + wdata->top + wdata->bottom;

   975 

   976     XtConfigureWidget(wdata->winData.comp.widget, x, y, width, height, 0 );

   977 }

   978 

   979 

   980 

   981 /* innerCanvasEH() is event handler for inner/parent canvas. It handles

   982    map and configure notify events. It reads width and height, adjusts

   983    for menubar insertion / removal and configures outer/child canvas.   */

   984 

   985 static void

   986 innerCanvasEH(Widget canvasW, XtPointer client_data, XEvent *event,

   987               Boolean* continueToDispatch)

   988 {

   989     JNIEnv      *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   990     jobject     this = (jobject) client_data;

   991     jobject     target;

   992     struct FrameData *wdata;

   993 

   994 

   995     wdata = (struct FrameData *)

   996         JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData);

   997     if  (wdata == NULL) {

   998         return;

   999     }

  1000 

  1001     if  ((*env)->EnsureLocalCapacity(env, 1) < 0)

  1002         return;

  1003 

  1004     target = (*env)->GetObjectField(env, (jobject) client_data,

  1005                                     mComponentPeerIDs.target);

  1006 

  1007     /* While inside ...pSetMenuBar(), don't react to incomplete resizing

  1008        events supplied by Xt toolkit. Wait for completion of the routine. */

  1009 

  1010 

  1011     /* For a map or resize, we need to check for the addition or deletion

  1012        of a menu bar to the form which is the of this drawing area (canvas).

  1013        We also must then configure the outer/child canvas appropriately.  */

  1014 

  1015     if  ( (event->xany.type == MapNotify) ||

  1016           (event->xany.type == ConfigureNotify) )

  1017     {

  1018         reconfigureOuterCanvas( env, target, this, wdata );

  1019     }

  1020 

  1021     (*env)->DeleteLocalRef(env, target);

  1022 

  1023 }

  1024 

  1025 /* syncTopLevelPos() is necessary to insure that the window manager has in

  1026  * fact moved us to our final position relative to the reParented WM window.

  1027  * We have noted a timing window which our shell has not been moved so we

  1028  * screw up the insets thinking they are 0,0.  Wait (for a limited period of

  1029  * time to let the WM hava a chance to move us

  1030  */

  1031 void syncTopLevelPos( Display *d, Window w, XWindowAttributes *winAttr )

  1032 {

  1033     int32_t i = 0;

  1034     memset(winAttr, 0, sizeof(*winAttr));

  1035 

  1036     do {

  1037         if (!XGetWindowAttributes(d, w, winAttr)) {

  1038             memset(winAttr, 0, sizeof(*winAttr));

  1039             break;

  1040         }

  1041         /* Sometimes we get here before the WM has updated the

  1042         ** window data struct with the correct position.  Loop

  1043         ** until we get a non-zero position.

  1044         */

  1045         if ((winAttr->x != 0) || (winAttr->y != 0)) {

  1046             break;

  1047         }

  1048         else {

  1049             /* What we really want here is to sync with the WM,

  1050             ** but there's no explicit way to do this, so we

  1051             ** call XSync for a delay.

  1052             */

  1053             XSync(d, False);

  1054         }

  1055     } while (i++ < 50);

  1056 }

  1057 

  1058 typedef struct FocusOutInfo_str {

  1059     XEvent * eventOut;

  1060     Window inWin;

  1061     Window inChild;

  1062     Widget defChild;

  1063     jobject childComp;

  1064 } FocusOutInfo_t;

  1065 

  1066 #define IsCanvasTypeWidget(w) \

  1067         (XtIsSubclass(w, xmDrawingAreaWidgetClass) ||\

  1068         XtIsSubclass(w, vDrawingAreaClass))

  1069 

  1070 int isTopLevelPartWidget(Widget w) {

  1071     if (XtIsShell(w)) {

  1072         return TRUE;

  1073     }

  1074     if (XtIsSubclass(w, xmFormWidgetClass)) {

  1075         return TRUE;

  1076     }

  1077     if (IsCanvasTypeWidget(w)) {

  1078         Widget w1 = XtParent(w);

  1079         if (w1 != NULL) {

  1080             if (XtIsSubclass(w1, xmFormWidgetClass)) {

  1081                 return TRUE;

  1082             }

  1083             if (IsCanvasTypeWidget(w1)) {

  1084                 Widget w2 = XtParent(w1);

  1085                 if (w2 != NULL) {

  1086                     if (XtIsSubclass(w2, xmFormWidgetClass)) {

  1087                         return TRUE;

  1088                     }

  1089                 }

  1090             }

  1091 

  1092         }

  1093     }

  1094     return FALSE;

  1095 }

  1096 

  1097 void

  1098 shellFocusEH(Widget w, XtPointer data, XEvent *event, Boolean *continueToDispatch)

  1099 {

  1100     JNIEnv      *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

  1101     jobject     this = (jobject) data;

  1102     jobject     target;

  1103     struct FrameData *wdata;

  1104 

  1105     /* Any event handlers which take peer instance pointers as

  1106      * client_data should check to ensure the widget has not been

  1107      * marked as destroyed as a result of a dispose() call on the peer

  1108      * (which can result in the peer instance pointer already haven

  1109      * been gc'd by the time this event is processed)

  1110      */

  1111     if (w->core.being_destroyed) {

  1112         return;

  1113     }

  1114 

  1115     wdata = (struct FrameData *)

  1116         JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.pData);

  1117     if (wdata == NULL) {

  1118         return;

  1119     }

  1120 

  1121     switch (event->xany.type) {

  1122       case FocusOut:

  1123           // Will be handled by proxy automaticall since he is focus owner

  1124         break;

  1125       case FocusIn:

  1126         // Forward focus event to the proxy

  1127         XSetInputFocus(awt_display, XtWindow(wdata->focusProxy), RevertToParent, CurrentTime);

  1128         break;

  1129     }

  1130 }

  1131 

  1132 /**

  1133  * Fix for Alt-Tab problem.

  1134  * See coments on use semantics below.