1 /*

     2  * Copyright (c) 1995, 2007, Oracle and/or its affiliates. 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.  Oracle designates this

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

     9  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include "awt_p.h"

    27 

    28 #include <sys/time.h>

    29 #include <limits.h>

    30 #include <locale.h>

    31 

    32 #ifndef HEADLESS

    33 #include <X11/cursorfont.h>

    34 #include <Xm/MenuShell.h>

    35 #include <Xm/RowColumn.h>

    36 #endif /* !HEADLESS */

    37 

    38 #include <jvm.h>

    39 #include <jni.h>

    40 #include <jlong.h>

    41 #include <jni_util.h>

    42 

    43 /* JNI headers */

    44 #include "java_awt_AWTEvent.h"

    45 #include "java_awt_Frame.h"

    46 #include "java_awt_SystemColor.h"

    47 #include "sun_awt_motif_MToolkit.h"

    48 

    49 /* JNI field and method ids */

    50 #include "awt_Component.h"

    51 //#include "awt_Cursor.h"

    52 #include "awt_MenuComponent.h"

    53 #include "awt_TopLevel.h"

    54 #include "canvas.h"

    55 #include "color.h"

    56 #include "awt_mgrsel.h"

    57 #include "awt_wm.h"

    58 #include "awt_DrawingSurface.h"

    59 #include "awt_Window.h"

    60 #include "awt_xembed.h"

    61 #include "awt_xembed_server.h"

    62 

    63 extern JavaVM *jvm;

    64 

    65 #ifndef HEADLESS

    66 #ifdef __linux__

    67 extern void statusWindowEventHandler(XEvent event);

    68 #endif

    69 #endif /* !HEADLESS */

    70 

    71 JNIEXPORT jint JNICALL

    72 JNI_OnLoad(JavaVM *vm, void *reserved)

    73 {

    74 #ifndef HEADLESS

    75     awt_util_debug_init();

    76 #endif /* !HEADLESS */

    77     jvm = vm;

    78     return JNI_VERSION_1_2;

    79 }

    80 

    81 JNIEXPORT jboolean JNICALL AWTIsHeadless() {

    82 #ifdef HEADLESS

    83     return JNI_TRUE;

    84 #else

    85     return JNI_FALSE;

    86 #endif

    87 }

    88 

    89 #ifndef HEADLESS

    90 static jlong awtJNI_TimeMillis(void);

    91 extern void awt_initialize_Xm_DnD(Display*);

    92 extern void awt_initialize_DataTransferer();

    93 

    94 extern Display *awt_init_Display(JNIEnv *env);

    95 

    96 extern void X11SD_LibDispose(JNIEnv *env);

    97 

    98 extern Widget drag_source = NULL;

    99 

   100 extern struct ComponentIDs componentIDs;

   101 extern struct MenuComponentIDs menuComponentIDs;

   102 extern struct MComponentPeerIDs mComponentPeerIDs;

   103 extern struct WindowIDs windowIDs;

   104 

   105 static Atom _XA_XSETTINGS_SETTINGS = None;

   106 struct xsettings_callback_cookie {

   107     jobject mtoolkit;

   108     jmethodID upcallMID;

   109 };

   110 

   111 static struct xsettings_callback_cookie xsettings_callback_cookie;

   112 

   113 

   114 static XEvent focusOutEvent;

   115 

   116 static void awt_pipe_init(void);

   117 static void processOneEvent(XtInputMask iMask);

   118 extern void waitForEvents(JNIEnv *env, int32_t fdXPipe, int32_t fdAWTPipe);

   119 #ifdef USE_SELECT

   120 static void performSelect(JNIEnv *env, int32_t fdXPipe, int32_t fdAWTPipe);

   121 #else

   122 static void performPoll(JNIEnv *env,int32_t fdXPipe, int32_t fdAWTPipe);

   123 #endif

   124 

   125 

   126 #include <X11/Intrinsic.h>

   127 #include <dlfcn.h>

   128 #include <fcntl.h>

   129 

   130 #ifdef USE_SELECT

   131 #if defined(AIX)

   132 #include <sys/select.h>

   133 #endif

   134 #else

   135 #include <poll.h>

   136 #ifndef POLLRDNORM

   137 #define POLLRDNORM POLLIN

   138 #endif

   139 #endif

   140 

   141 #ifdef NDEBUG

   142 #undef DEBUG            /* NDEBUG overrides DEBUG */

   143 #endif

   144 

   145 static struct WidgetInfo *awt_winfo = (struct WidgetInfo *) NULL;

   146 static struct MenuList* menu_list = (struct MenuList*) NULL;

   147 

   148 #ifndef bzero

   149 #define bzero(a,b) memset(a, 0, b)

   150 #endif

   151 

   152 static jboolean syncUpdated = JNI_FALSE;

   153 static jboolean syncFailed = JNI_FALSE;

   154 static jint eventNumber = 0;

   155 static void syncWait_eventHandler(XEvent *);

   156 static Atom oops_atom = None;

   157 static Atom wm_selection = None;

   158 static Atom version_atom = None;

   159 

   160 static Boolean inSyncWait = False;

   161 

   162 Widget grabbed_widget = NULL;

   163 

   164 XtAppContext awt_appContext;

   165 Widget awt_root_shell;

   166 Pixel awt_defaultBg;

   167 Pixel awt_defaultFg;

   168 int32_t awt_multiclick_time;        /* milliseconds */

   169 uint32_t awt_MetaMask = 0;

   170 uint32_t awt_AltMask = 0;

   171 uint32_t awt_NumLockMask = 0;

   172 uint32_t awt_ModeSwitchMask = 0;

   173 Cursor awt_scrollCursor;

   174 Boolean  awt_ModLockIsShiftLock = False;

   175 extern Boolean awt_UseType4Patch;

   176 extern Boolean awt_UseXKB;

   177 

   178 #define SPECIAL_KEY_EVENT 2

   179 

   180 /* implement a "putback queue" -- see comments on awt_put_back_event() */

   181 #define PUTBACK_QUEUE_MIN_INCREMENT 5   /* min size increase */

   182 static XEvent *putbackQueue = NULL;     /* the queue -- next event is 0 */

   183 static int32_t putbackQueueCount = 0;   /* # of events available on queue */

   184 static int32_t putbackQueueCapacity = 0;        /* total capacity of queue */

   185 static XtInputMask awt_events_pending(XtAppContext appContext);

   186 static int32_t awt_get_next_put_back_event(XEvent *xev_out);

   187 

   188 #define AWT_FLUSH_TIMEOUT    ((uint32_t)100) /* milliseconds */

   189 #define AWT_MIN_POLL_TIMEOUT ((uint32_t)0) /* milliseconds */

   190 #define AWT_MAX_POLL_TIMEOUT ((uint32_t)250) /* milliseconds */

   191 

   192 #define AWT_POLL_BUFSIZE        100

   193 #define AWT_READPIPE            (awt_pipe_fds[0])

   194 #define AWT_WRITEPIPE           (awt_pipe_fds[1])

   195 #define AWT_FLUSHOUTPUT_NOW()  \

   196 {                              \

   197     XFlush(awt_display);       \

   198     awt_next_flush_time = 0LL; \

   199 }

   200 

   201 typedef XtIntervalId (*XTFUNC)();

   202 

   203 static jobject  awt_MainThread = NULL;

   204 static char     read_buf[AWT_POLL_BUFSIZE + 1];    /* dummy buf to empty pipe */

   205 static int32_t      awt_pipe_fds[2];                   /* fds for wkaeup pipe */

   206 static Boolean  awt_pipe_inited = False;           /* make sure pipe is initialized before write */

   207 static int32_t      def_poll_timeout = AWT_MAX_POLL_TIMEOUT;   /* default value for timeout */

   208 static jlong awt_next_flush_time = 0LL; /* 0 == no scheduled flush */

   209 static void     *xt_lib = NULL;

   210 static XTFUNC   xt_timeout = NULL;

   211 

   212 #ifdef DEBUG_AWT_LOCK

   213 

   214 int32_t awt_locked = 0;

   215 char *lastF = "";

   216 int32_t lastL = -1;

   217 

   218 #endif

   219 

   220 #ifndef NOMODALFIX

   221 extern Boolean awt_isModal();

   222 extern Boolean awt_isWidgetModal(Widget w);

   223 #endif

   224 

   225 Boolean keyboardGrabbed = False;

   226 

   227 static uint32_t curPollTimeout = AWT_MAX_POLL_TIMEOUT;

   228 

   229 /* Font information to feed Motif widgets. */

   230 static const char      *motifFontList;

   231 static XFontSet        defaultMotifFontSet;

   232 static XFontStruct     *defaultMotifFontStruct;

   233 static const char *defaultMotifFont =  /* a.k.a "fixed", known everywhere */

   234         "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1";

   235 

   236 XFontSet getMotifFontSet() {

   237     char    **missingList;

   238     int32_t     missingCount;

   239     char    *defChar;

   240 

   241     return XCreateFontSet(awt_display, motifFontList,

   242                           &missingList, &missingCount, &defChar);

   243 }

   244 

   245 XFontStruct *getMotifFontStruct() {

   246     return XLoadQueryFont(awt_display, defaultMotifFont);

   247 }

   248 

   249 XmFontList getMotifFontList() {

   250     XmFontListEntry motifFontListEntry;

   251     XmFontList fontlist;

   252 

   253     if (strchr(motifFontList, ',') == NULL) {

   254         /* If the default font is a single font. */

   255         if (defaultMotifFontStruct == NULL)

   256             defaultMotifFontStruct = getMotifFontStruct();

   257         motifFontListEntry = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG,

   258                                                    XmFONT_IS_FONT,

   259                                            (XtPointer)defaultMotifFontStruct);

   260     }

   261     else {

   262         /* If the default font is multiple fonts. */

   263         if (defaultMotifFontSet == NULL)

   264             defaultMotifFontSet = getMotifFontSet();

   265             motifFontListEntry = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG,

   266                                                XmFONT_IS_FONTSET,

   267                                                (XtPointer)defaultMotifFontSet);

   268     }

   269     fontlist = XmFontListAppendEntry(NULL, motifFontListEntry);

   270     XmFontListEntryFree(&motifFontListEntry);

   271     return fontlist;

   272 }

   273 

   274 static void

   275 awt_set_poll_timeout (uint32_t newTimeout)

   276 {

   277     DTRACE_PRINTLN1("awt_set_poll_timeout(%lu)", newTimeout);

   278 

   279     newTimeout = max(AWT_MIN_POLL_TIMEOUT, newTimeout);

   280     newTimeout = min(AWT_MAX_POLL_TIMEOUT, newTimeout);

   281     newTimeout = min(newTimeout, curPollTimeout);

   282     curPollTimeout = newTimeout;

   283 

   284 } /* awt_set_poll_timeout */

   285 

   286 /*

   287  * Gets the best timeout for the next call to poll() or select().

   288  * If timedOut is True, we assume that our previous timeout elapsed

   289  * with no events/timers arriving. Therefore, we can increase the

   290  * next timeout slightly.

   291  */

   292 static uint32_t

   293 awt_get_poll_timeout( Boolean timedOut )

   294 {

   295     uint32_t timeout = AWT_MAX_POLL_TIMEOUT;

   296 

   297     DTRACE_PRINTLN2("awt_get_poll_timeout(%s), awt_next_flush_time:%ld",

   298         (remove?"true":"false"),

   299         awt_next_flush_time);

   300 

   301     if (timedOut) {

   302         /* add 1/16 (plus 1, in case the division truncates to 0) */

   303         curPollTimeout += ((curPollTimeout>>4) + 1);

   304         curPollTimeout = min(AWT_MAX_POLL_TIMEOUT, curPollTimeout);

   305     }

   306     if (awt_next_flush_time > 0) {

   307         int32_t flushDiff = (int32_t)(awt_next_flush_time - awtJNI_TimeMillis());

   308         timeout = min(curPollTimeout, flushDiff);

   309     } else {

   310         timeout = curPollTimeout;

   311     }

   312 

   313     return timeout;

   314 } /* awt_get_poll_timeout() */

   315 

   316 static jlong

   317 awtJNI_TimeMillis(void)

   318 {

   319     struct timeval t;

   320 

   321     gettimeofday(&t, 0);

   322 

   323     return jlong_add(jlong_mul(jint_to_jlong(t.tv_sec), jint_to_jlong(1000)),

   324                      jint_to_jlong(t.tv_usec / 1000));

   325 }

   326 

   327 static int32_t

   328 xtError()

   329 {

   330 #ifdef DEBUG

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

   332 

   333     jio_fprintf(stderr, "Xt error\n");

   334     JNU_ThrowNullPointerException(env, "NullPointerException");

   335 #endif

   336     return 0;

   337 }

   338 

   339 static int32_t

   340 xIOError(Display *dpy)

   341 {

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

   343     jclass cl = (*env)->FindClass(env, "java/lang/Thread");

   344 

   345     if (errno == EPIPE) {

   346         jio_fprintf(stderr, "X connection to %s host broken (explicit kill or server shutdown)\n", XDisplayName(NULL));

   347     }

   348     AWT_NOFLUSH_UNLOCK();

   349     JVM_RaiseSignal(JVM_SIGTERM); /* Shut down cleanly */

   350     if (cl != NULL) {

   351         JVM_Sleep(env, cl, 20000);

   352     }

   353 

   354     return 0; /* to keep compiler happy */

   355 }

   356 

   357 /* Like XKeysymToKeycode, but ensures that keysym is the primary

   358  * symbol on the keycode returned.  Returns zero otherwise.

   359  */

   360 static int32_t

   361 keysym_to_keycode_if_primary(Display *dpy, KeySym sym)

   362 {

   363     KeyCode code;

   364     KeySym primary;

   365 

   366     code = XKeysymToKeycode(dpy, sym);

   367     if (code == 0) {

   368         return 0;

   369     }

   370 

   371     primary = XKeycodeToKeysym(dpy, code, 0);

   372     if (sym == primary) {

   373         return code;

   374     } else {

   375         return 0;

   376     }

   377 }

   378 /*

   379  * +kb or -kb ?

   380  */

   381 static Boolean

   382 isXKBenabled(Display *display) {

   383     int mop, beve, berr;

   384     /*

   385      * NB: TODO: hope it will return False if XkbIgnoreExtension was called!

   386      */

   387     return XQueryExtension(display, "XKEYBOARD", &mop, &beve, &berr);

   388 }

   389 

   390 

   391 /* Assign meaning - alt, meta, etc. - to X modifiers mod1 ... mod5.

   392  * Only consider primary symbols on keycodes attached to modifiers.

   393  */

   394 static void

   395 setup_modifier_map(Display *disp)

   396 {

   397     KeyCode metaL      = keysym_to_keycode_if_primary(disp, XK_Meta_L);

   398     KeyCode metaR      = keysym_to_keycode_if_primary(disp, XK_Meta_R);

   399     KeyCode altL       = keysym_to_keycode_if_primary(disp, XK_Alt_L);

   400     KeyCode altR       = keysym_to_keycode_if_primary(disp, XK_Alt_R);

   401     KeyCode numLock    = keysym_to_keycode_if_primary(disp, XK_Num_Lock);

   402     KeyCode modeSwitch = keysym_to_keycode_if_primary(disp, XK_Mode_switch);

   403     KeyCode shiftLock  = keysym_to_keycode_if_primary(disp, XK_Shift_Lock);

   404     KeyCode capsLock   = keysym_to_keycode_if_primary(disp, XK_Caps_Lock);

   405 

   406     XModifierKeymap *modmap = NULL;

   407     int32_t nkeys, modn, i;

   408     char *ptr = NULL;

   409 

   410     DTRACE_PRINTLN("In setup_modifier_map");

   411 

   412     modmap = XGetModifierMapping(disp);

   413     nkeys = modmap->max_keypermod;

   414 

   415     for (modn = Mod1MapIndex;

   416          (modn <= Mod5MapIndex) &&

   417              (awt_MetaMask == 0 || awt_AltMask == 0 ||

   418               awt_NumLockMask == 0 || awt_ModeSwitchMask == 0);

   419          ++modn)

   420     {

   421         static const uint32_t modmask[8] = {

   422             ShiftMask, LockMask, ControlMask,

   423             Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask

   424         };

   425 

   426 

   427         for (i = 0; i < nkeys; ++i) {

   428             /* for each keycode attached to this modifier */

   429             KeyCode keycode = modmap->modifiermap[modn * nkeys + i];

   430             if (keycode == 0) {

   431                 continue;

   432             }

   433 

   434             if (awt_MetaMask == 0 && (keycode == metaL || keycode == metaR)) {

   435                 awt_MetaMask = modmask[modn];

   436                 DTRACE_PRINTLN2("    awt_MetaMask       = %d, modn = %d", awt_MetaMask, modn);

   437                 break;

   438             } else if (awt_AltMask == 0 && (keycode == altL || keycode == altR)) {

   439                 awt_AltMask = modmask[modn];

   440                 DTRACE_PRINTLN2("    awt_AltMask        = %d, modn = %d", awt_AltMask, modn);

   441                 break;

   442             } else if (awt_NumLockMask == 0 && keycode == numLock) {

   443                 awt_NumLockMask = modmask[modn];

   444                 DTRACE_PRINTLN2("    awt_NumLockMask    = %d, modn = %d", awt_NumLockMask, modn);

   445                 break;

   446             } else if (awt_ModeSwitchMask == 0 && keycode == modeSwitch) {

   447                 awt_ModeSwitchMask = modmask[modn];

   448                 DTRACE_PRINTLN2("    awt_ModeSwitchMask = %d, modn = %d", awt_ModeSwitchMask, modn);

   449                 break;

   450             }

   451         }

   452     }

   453     for(i = 0; i < nkeys; i++) {

   454         KeyCode keycode = modmap->modifiermap[LockMapIndex * nkeys + i];

   455         if (keycode == 0) {

   456             break;

   457         }

   458         if (keycode == shiftLock) {

   459             awt_ModLockIsShiftLock = True;

   460             break;

   461         }

   462         if (keycode == capsLock) {

   463             break;

   464         }

   465     }

   466 

   467     DTRACE_PRINTLN1("    ShiftMask          = %d", ShiftMask);

   468     DTRACE_PRINTLN1("    ControlMask        = %d", ControlMask);

   469 

   470     XFreeModifiermap(modmap);

   471     ptr = getenv("_AWT_USE_TYPE4_PATCH");

   472     if( ptr != NULL && ptr[0] != 0 ) {

   473         if( strncmp("true", ptr, 4) == 0 ) {

   474            awt_UseType4Patch = True;

   475         }else if( strncmp("false", ptr, 5) == 0 ) {

   476            awt_UseType4Patch = False;

   477         }

   478     }

   479     awt_UseXKB = isXKBenabled(disp);

   480 

   481 }

   482 

   483 

   484 Boolean scrollBugWorkAround;

   485 

   486 

   487 void

   488 awt_output_flush()

   489 {

   490     char c = 'p';

   491 

   492     if (awt_next_flush_time == 0)

   493     {

   494         Boolean needsWakeup = False;

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

   496         if (awt_pipe_inited && (awt_get_poll_timeout(False) > (2*AWT_FLUSH_TIMEOUT))){

   497             needsWakeup = True;

   498         }

   499         /* awt_next_flush_time affects awt_get_poll_timeout(), so set

   500          * the variable *after* calling the function.

   501          */

   502         awt_next_flush_time = awtJNI_TimeMillis() + AWT_FLUSH_TIMEOUT;

   503         if (needsWakeup)

   504         {

   505             /* write to the utility pipe to wake up the event

   506              * loop, if it's sleeping

   507              */

   508             write ( AWT_WRITEPIPE, &c, 1 );

   509         }

   510     }

   511 #ifdef FLUSHDEBUG

   512 else

   513 jio_fprintf(stderr, "!");

   514 #endif

   515 } /* awt_output_flush() */

   516 

   517 void

   518 null_event_handler(Widget w, XtPointer client_data,

   519                    XEvent * event, Boolean * cont)

   520 {

   521     /* do nothing */

   522 }

   523 

   524 struct WidgetInfo *

   525 findWidgetInfo(Widget widget)

   526 {

   527     struct WidgetInfo *cw;

   528 

   529     for (cw = awt_winfo; cw != NULL; cw = cw->next) {

   530         if (cw->widget == widget || cw->origin == widget) {

   531             return cw;

   532         }

   533     }

   534     return NULL;

   535 }

   536 

   537 void

   538 awt_addWidget(Widget w, Widget origin, void *peer, jlong event_flags)

   539 {

   540     if (findWidgetInfo(w) != NULL) return;

   541 

   542     if (!XtIsSubclass(w, xmFileSelectionBoxWidgetClass)) {

   543         struct WidgetInfo *nw = (struct WidgetInfo *) malloc(sizeof(struct WidgetInfo));

   544 

   545         if (nw) {

   546             nw->widget     = w;

   547             nw->origin     = origin;

   548             nw->peer       = peer;

   549             nw->event_mask = event_flags;

   550             nw->next       = awt_winfo;

   551             awt_winfo      = nw;

   552 

   553             if (event_flags & java_awt_AWTEvent_MOUSE_EVENT_MASK) {

   554                 XtAddEventHandler(w,

   555                                   ButtonPressMask | ButtonReleaseMask |

   556                                   EnterWindowMask | LeaveWindowMask,

   557                                   False, null_event_handler, NULL);

   558                 if (w != origin) {

   559                     XtAddEventHandler(origin,

   560                                       ButtonPressMask | ButtonReleaseMask |

   561                                       EnterWindowMask | LeaveWindowMask,

   562                                       False, null_event_handler, NULL);

   563                 }

   564             }

   565             if (event_flags & java_awt_AWTEvent_MOUSE_MOTION_EVENT_MASK) {

   566                 XtAddEventHandler(w,

   567                                   PointerMotionMask,

   568                                   False, null_event_handler, NULL);

   569                 if (w != origin) {

   570                     XtAddEventHandler(origin,

   571                                       PointerMotionMask,

   572                                       False, null_event_handler, NULL);

   573                 }

   574             }

   575             if (event_flags & java_awt_AWTEvent_KEY_EVENT_MASK) {

   576                 XtAddEventHandler(w,

   577                                   KeyPressMask | KeyReleaseMask,

   578                                   False, null_event_handler, NULL);

   579                 if (w != origin) {

   580                     XtAddEventHandler(origin,

   581                                       KeyPressMask | KeyReleaseMask,

   582                                       False, null_event_handler, NULL);

   583                 }

   584             }

   585         } else {

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

   587             JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");

   588         }

   589 

   590     }

   591 }

   592 

   593 void

   594 awt_delWidget(Widget w)

   595 {

   596     struct WidgetInfo *cw;

   597 

   598     if (awt_winfo != NULL) {

   599         if ((awt_winfo->widget == w) ||

   600             (awt_winfo->origin == w)) {

   601             cw = awt_winfo;

   602             awt_winfo = awt_winfo->next;

   603             free((void *) cw);

   604         } else {

   605             struct WidgetInfo *pw;

   606 

   607             for (pw = awt_winfo, cw = awt_winfo->next;

   608                  cw != NULL;

   609                  pw = cw, cw = cw->next) {

   610                 if ((cw->widget == w) ||

   611                     (cw->origin == w)) {

   612                     pw->next = cw->next;

   613                     free((void *) cw);

   614                     break;

   615                 }

   616             }

   617         }

   618     }

   619 }

   620 

   621 

   622 void *

   623 findPeer(Widget * pwidget)

   624 {

   625     struct WidgetInfo   *cw;

   626     Widget widgetParent;

   627     void * peer;

   628 

   629     if ((cw = findWidgetInfo(*pwidget)) != NULL) {

   630         return cw->peer;

   631     }

   632     /* fix for 4053856, robi.khan@eng

   633        couldn't find peer corresponding to widget

   634        but the widget may be child of one with

   635        a peer, so recurse up the hierarchy */

   636     widgetParent = XtParent(*pwidget);

   637     if (widgetParent != NULL ) {

   638         peer = findPeer(&widgetParent);

   639         if( peer != NULL ) {

   640         /* found peer attached to ancestor of given

   641            widget, so set widget return value as well */

   642             *pwidget = widgetParent;

   643             return peer;

   644         }

   645     }

   646 

   647     return NULL;

   648 }

   649 

   650 Boolean

   651 awt_isAwtWidget(Widget widget)

   652 {

   653     return (findWidgetInfo(widget) != NULL);

   654 }

   655 

   656 

   657 static Boolean

   658 awt_isAwtMenuWidget(Widget wdgt) {

   659     struct MenuList* cur;

   660 

   661     if (!XtIsSubclass(wdgt, xmRowColumnWidgetClass)) {

   662         return False;

   663     }

   664     for (cur = menu_list; cur != NULL; cur = cur->next) {

   665         if (cur->menu == wdgt) {

   666             return True;

   667         }

   668     }

   669     return False;

   670 }

   671 

   672 void

   673 awt_addMenuWidget(Widget wdgt) {

   674     DASSERT(XtIsSubclass(wdgt, xmRowColumnWidgetClass));

   675 

   676     if (!awt_isAwtMenuWidget(wdgt)) {

   677         struct MenuList* ml = (struct MenuList*) malloc(sizeof(struct MenuList));

   678         if (ml != NULL) {

   679             ml->menu = wdgt;

   680             ml->next = menu_list;

   681             menu_list = ml;

   682         } else {

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

   684             JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");

   685         }

   686     }

   687 }

   688 

   689 void

   690 awt_delMenuWidget(Widget wdgt) {

   691     struct MenuList** pp;

   692     struct MenuList* p;

   693 

   694     DASSERT(XtIsSubclass(wdgt, xmRowColumnWidgetClass));

   695 

   696     for (pp = &menu_list; *pp != NULL; pp = &((*pp)->next)) {

   697         if ((*pp)->menu == wdgt) {

   698             p = *pp;

   699             *pp = (*pp)->next;

   700             free((void*)p);

   701             break;

   702         }

   703     }

   704 }

   705 

   706 

   707 static Widget

   708 getShellWidgetByPart(Widget part) {

   709     int i;

   710     for (i = 0; i < 3; i++) {

   711         if (part == NULL) return NULL;

   712         if (XtIsShell(part)) return part;

   713         part = XtParent(part);

   714     }

   715     return NULL;

   716 }

   717 

   718 static Boolean

   719 isTheSameShellWidget(Widget shell, Widget w) {

   720     Widget s1, s2;

   721     if (shell == NULL || w == NULL) return False;

   722     s1 = getShellWidgetByPart(shell);

   723     s2 = getShellWidgetByPart(w);

   724     if (s1 == s2 && s1 != NULL) {

   725         return True;

   726     } else {

   727         return False;

   728     }

   729 }

   730 

   731 static Boolean

   732 shouldDispatchToWidget(XEvent * xev)

   733 {

   734   /* If this function returns False, that means that it has not pre-posted

   735      this event to Java. The caller will then dispatch the event to Motif,

   736      and our handlers will be called to post it to Java.

   737      If this function returns true, then this function has posted this event

   738      to java before returning. The caller will not dispatch it to Motif;

   739      it will be dispatched to Motif via the putbackQueue after it has been

   740      processed by Java */

   741 

   742     Window win;

   743     Widget widget = NULL;

   744     struct WidgetInfo *winfo;

   745     void *peer = NULL;

   746     Boolean cont = FALSE;

   747 

   748     switch (xev->type) {

   749         case KeyPress:

   750         case KeyRelease:

   751             win = xev->xkey.window;

   752             break;

   753         case FocusIn:

   754         case FocusOut:

   755             win = xev->xfocus.window;

   756             break;

   757         case ButtonPress:

   758         case ButtonRelease:

   759             win = xev->xbutton.window;

   760             break;

   761         case MotionNotify:

   762             win = xev->xmotion.window;

   763             break;

   764         case EnterNotify:

   765         case LeaveNotify:

   766             win = xev->xcrossing.window;

   767             break;

   768         default:

   769             return False;

   770     }

   771 

   772     if ((widget = XtWindowToWidget(awt_display, win)) == NULL) {

   773         return False;

   774     }

   775 

   776     if (xev->type == KeyPress || xev->type == KeyRelease) {

   777         Widget focusWidget = XmGetFocusWidget(widget);

   778 

   779         /* Fix for 4328561 by ibd@sparc.spb.su

   780            If the widget is a Choice, the widget with focus is probably lying

   781            outside the current widget's sub-hierarchy, so we have to go up the

   782            hierarchy to reach it */

   783 

   784         if ((focusWidget == NULL) && XmIsMenuShell(widget)) {

   785             if ((widget = XtParent(widget)) != NULL) {

   786                 focusWidget = XmGetFocusWidget(widget);

   787             } else {

   788                 return False;

   789             }

   790 

   791             /* In this case, focus widget should be CascadeButtonGadget type,

   792                but we should send the events to its parent */

   793             if (focusWidget != NULL && XmIsCascadeButtonGadget(focusWidget)) {

   794                 widget = XtParent(focusWidget);

   795             } else {

   796                 /* If something went wrong, restore the original status */

   797                 widget = XtWindowToWidget(awt_display, win);

   798             }

   799         }

   800 

   801         /* if focus owner is null, redirect key events to focused window */

   802         if (focusWidget == NULL && findWidgetInfo(widget) == NULL) {

   803             focusWidget = findTopLevelByShell(widget);

   804         }

   805 

   806         /* If we are on a non-choice widget, process events in a normal way */

   807         if ((focusWidget != NULL) && (focusWidget != widget)) {

   808             if (isTheSameShellWidget(focusWidget, widget)) {

   809                 focusWidget = findTopLevelByShell(widget);

   810             }

   811             if (focusWidget != NULL) {

   812                 peer = findPeer(&focusWidget);

   813             }

   814             if (peer != NULL) {

   815                 widget = focusWidget;

   816                 win = xev->xkey.window = XtWindow(focusWidget);

   817             }

   818         }

   819     }

   820 

   821     if ((winfo = findWidgetInfo(widget)) == NULL) {

   822         return False;

   823     }

   824 

   825     /*

   826      * Fix for bug 4145193

   827      *

   828      * If a menu is up (not just a popup menu), prevent awt components from

   829      * getting any events until the menu is popped down.

   830      * Before this fix, the fact that mouse/button events were

   831      * preposted to the Java event queue was causing the ButtonRelease

   832      * (needed to pop menu down) to be seen by the menu's parent and

   833      * not the menu.

   834      */

   835     if (awtMenuIsActive()) {

   836         Widget focusWidget = XmGetFocusWidget(widget);

   837 

   838         if (focusWidget == NULL) {

   839             return False;

   840         }

   841 

   842         /* If we are on a choice, dispatch the events to widget, but do not

   843          * dispatch the events if we are on popped up menu.

   844          */

   845         if (!XmIsRowColumn(widget) || !XmIsCascadeButtonGadget(focusWidget)) {

   846             /* Fix for 4328557 by ibd@sparc.spb.su

   847              * If we are dragging mouse from choice and are currently outside

   848              * of it, dispatch events to the choice - the source of dragging.

   849              */

   850 

   851             if ((drag_source != NULL) && (widget != drag_source) &&

   852                 (peer = findPeer(&drag_source))) {

   853                 awt_canvas_handleEvent(drag_source, peer, xev, winfo, &cont, TRUE);

   854             }

   855             return False;

   856         }

   857     }

   858 

   859     /* If the keyboard is grabbed by a popup (such as a choice) during

   860        a time when a focus proxy is in effect, the abovefocusIsOnMenu

   861        test will not detect the sitation because the focus will be on

   862        the proxy. But we need events to go to Motif first, so that the

   863        grab can be undone when appropriate. */

   864     if (keyboardGrabbed) {

   865         return False;

   866     }

   867 

   868     /* If it's a keyboard event, we need to find the peer associated */

   869     /* with the widget that has the focus rather than the widget */

   870     /* associated with the window in the X event. */

   871 

   872     switch (xev->type) {

   873       case KeyPress:

   874       case KeyRelease:

   875           if (!(winfo->event_mask & java_awt_AWTEvent_KEY_EVENT_MASK))

   876               return False;

   877           break;

   878         case FocusIn:

   879         case FocusOut:

   880             if (!(winfo->event_mask & java_awt_AWTEvent_FOCUS_EVENT_MASK))

   881                 return False;

   882             break;

   883         case ButtonPress:

   884         case ButtonRelease:

   885             if (!(winfo->event_mask & java_awt_AWTEvent_MOUSE_EVENT_MASK)) {

   886                 return False;

   887             }

   888             break;

   889         case EnterNotify:

   890         case LeaveNotify:

   891             /*

   892              * Do not post the enter/leave event if it's on a subwidget

   893              * within the component.

   894              */

   895             if (!(winfo->event_mask & java_awt_AWTEvent_MOUSE_EVENT_MASK) ||

   896                 widget != winfo->origin)

   897                 return False;

   898             break;

   899         case MotionNotify:

   900             if (!(winfo->event_mask & java_awt_AWTEvent_MOUSE_MOTION_EVENT_MASK))

   901                 return False;

   902             break;

   903         default:

   904             return False;

   905     }

   906 

   907     peer = winfo->peer;

   908 

   909     /* If we found a widget and a suitable peer (either the focus

   910        peer above or the one associated with the widget then we

   911        dispatch to it. */

   912     if (peer == NULL) {

   913         return False;

   914     }

   915 

   916     /*

   917      * Fix for bug 4173714 - java.awt.button behaves differently under

   918      * Win32/Solaris.

   919      * Component should not get any events when it's disabled.

   920      */

   921     if (!XtIsSensitive(widget)) {

   922         if (xev->type == EnterNotify) {

   923             updateCursor(peer, CACHE_UPDATE);

   924         }

   925         return False;

   926     }

   927 

   928     awt_canvas_handleEvent(widget, peer, xev, winfo, &cont, TRUE);

   929     return (!cont);

   930 } /* shouldDispatchToWidget() */

   931 

   932 

   933 void set_toolkit_busy(Boolean busy) {

   934 

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

   936 

   937     static jclass awtAutoShutdownClass = NULL;

   938     static jmethodID notifyBusyMethodID = NULL;

   939     static jmethodID notifyFreeMethodID = NULL;

   940 

   941     if (awtAutoShutdownClass == NULL) {

   942         jclass awtAutoShutdownClassLocal = (*env)->FindClass(env, "sun/awt/AWTAutoShutdown");

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

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

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

   946         }

   947         DASSERT(awtAutoShutdownClassLocal != NULL);

   948         if (awtAutoShutdownClassLocal == NULL) {

   949             return;

   950         }

   951 

   952         awtAutoShutdownClass = (jclass)(*env)->NewGlobalRef(env, awtAutoShutdownClassLocal);

   953         (*env)->DeleteLocalRef(env, awtAutoShutdownClassLocal);

   954 

   955         notifyBusyMethodID = (*env)->GetStaticMethodID(env, awtAutoShutdownClass,

   956                                                     "notifyToolkitThreadBusy", "()V");

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

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

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

   960         }

   961         notifyFreeMethodID = (*env)->GetStaticMethodID(env, awtAutoShutdownClass,

   962                                                     "notifyToolkitThreadFree", "()V");

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

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

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

   966         }

   967         DASSERT(notifyBusyMethodID != NULL);

   968         DASSERT(notifyFreeMethodID != NULL);

   969         if (notifyBusyMethodID == NULL || notifyFreeMethodID == NULL) {

   970             return;

   971         }

   972     } /* awtAutoShutdownClass == NULL*/

   973 

   974     if (busy) {

   975         (*env)->CallStaticVoidMethod(env, awtAutoShutdownClass,

   976                                      notifyBusyMethodID);

   977     } else {

   978         (*env)->CallStaticVoidMethod(env, awtAutoShutdownClass,

   979                                      notifyFreeMethodID);

   980     }

   981 

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

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

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

   985     }

   986 }

   987 

   988 #ifdef DEBUG

   989 static int32_t debugPrintLineCount = 0;   /* limit debug output per line */

   990 #endif

   991 

   992 /*

   993  * This is the main Xt event loop for the AWT.

   994  *

   995  * Because java applications are multithreaded, but X and Xt

   996  * are thread-dumb, we must make special considerations to

   997  * make ensure that the X/Xt libraries are not entered by

   998  * multiple threads simultaneously.

   999  *

  1000  * The biggest difference between the standard Xt loop

  1001  * and this loop is that we go to great lengths never to block

  1002  * in the X libraries. We poll() on the X event pipe, waiting

  1003  * for events, rather than simply calling XtAppNextEvent() and

  1004  * blocking. If this thread were to block in XtAppNextEvent(),

  1005  * no other thread could enter (e.g., to perform a paint or

  1006  * retrieve data).

  1007  */

  1008 /* #ifdef DEBUG */

  1009     int32_t  numEventsHandled = 0;

  1010 /* #endif */

  1011 static void

  1012 awt_MToolkit_loop(JNIEnv *env)

  1013 {

  1014     XtInputMask iMask;

  1015     int32_t  fdXPipe = -1;              /* pipe where X events arrive */

  1016 

  1017     /* only privileged thread should be running here */

  1018     DASSERT(awt_currentThreadIsPrivileged(env));

  1019 

  1020     /* The pipe where X events arrive */

  1021     fdXPipe = ConnectionNumber(awt_display) ;

  1022 

  1023     /* We execute events while locked, unlocking only when waiting

  1024      * for an event

  1025      */

  1026     AWT_LOCK();

  1027 

  1028     /* Create the AWT utility pipe. See the comments on awt_pipe_init() */

  1029     awt_pipe_init();

  1030 

  1031     /*

  1032      * Need to flush here in case data on the connection was read

  1033      * before we acquired the monitor.

  1034      *

  1035      * I don't get this, but I'm too chicken to remove it. -jethro 2Sep98

  1036      */

  1037     AWT_FLUSHOUTPUT_NOW();

  1038 

  1039     /*

  1040      * ACTUALLY PROCESS EVENTS

  1041      */

  1042     while(True) {

  1043 

  1044         /* process all events in the queue */

  1045 /*      #ifdef DEBUG */

  1046 /*          numEventsHandled = 0; */

  1047 /*      #endif */

  1048         while (((iMask = awt_events_pending(awt_appContext)) & XtIMAll) > 0) {

  1049 

  1050 /*          #ifdef DEBUG */

  1051                 ++numEventsHandled;

  1052 /*          #endif */

  1053             processOneEvent(iMask);

  1054 

  1055         }  /* end while awt_events_pending() */

  1056         /* At this point, we have exhausted the event queue */

  1057 

  1058         /* print the number of events handled in parens */

  1059         DTRACE_PRINT1("(%d events)",(int32_t)numEventsHandled);

  1060 #ifdef DEBUG

  1061         if (++debugPrintLineCount > 8) {

  1062             DTRACE_PRINTLN("");

  1063             debugPrintLineCount = 0;

  1064         }

  1065 #endif

  1066 

  1067         AWT_NOTIFY_ALL();               /* wake up modalWait() */

  1068 

  1069         set_toolkit_busy(False);

  1070 

  1071         /* Here, we wait for X events, outside of the X libs. When

  1072          * it's likely that an event is waiting, we process the queue

  1073          */

  1074         waitForEvents(env, fdXPipe, AWT_READPIPE);

  1075 

  1076         set_toolkit_busy(True);

  1077 

  1078     } /* while(True) */

  1079 

  1080     /* If we ever exit the loop, must unlock the toolkit */

  1081 

  1082 } /* awt_MToolkit_loop() */

  1083 

  1084 /*

  1085  * Creates the AWT utility pipe. This pipe exists solely so that

  1086  * we can cause the main event thread to wake up from a poll() or

  1087  * select() by writing to this pipe.

  1088  */

  1089 static void

  1090 awt_pipe_init(void) {

  1091 

  1092     if (awt_pipe_inited) {

  1093         return;

  1094     }

  1095 

  1096     if ( pipe ( awt_pipe_fds ) == 0 )

  1097     {

  1098         /*

  1099         ** the write wakes us up from the infinite sleep, which

  1100         ** then we cause a delay of AWT_FLUSHTIME and then we

  1101         ** flush.

  1102         */

  1103         int32_t flags = 0;

  1104         awt_set_poll_timeout (def_poll_timeout);

  1105         /* set the pipe to be non-blocking */

  1106         flags = fcntl ( AWT_READPIPE, F_GETFL, 0 );

  1107         fcntl( AWT_READPIPE, F_SETFL, flags | O_NDELAY | O_NONBLOCK );

  1108         flags = fcntl ( AWT_WRITEPIPE, F_GETFL, 0 );

  1109         fcntl( AWT_WRITEPIPE, F_SETFL, flags | O_NDELAY | O_NONBLOCK );

  1110         awt_pipe_inited = True;

  1111     }

  1112     else

  1113     {

  1114         AWT_READPIPE = -1;

  1115         AWT_WRITEPIPE = -1;

  1116         awt_pipe_inited = False;

  1117     }

  1118 } /* awt_pipe_init() */

  1119 

  1120 static Window

  1121 proxyTopLevel(Window proxyWindow) {

  1122     Window parent = None, root = None, *children = NULL, retvalue = None;

  1123     uint32_t nchildren = 0;

  1124     Status res = XQueryTree(awt_display, proxyWindow, &root, &parent,

  1125              &children, &nchildren);

  1126     if (res != 0) {

  1127         if (nchildren > 0) {

  1128             retvalue = children[0];

  1129         }

  1130         else retvalue = None;

  1131         if (children != NULL) {

  1132             XFree(children);

  1133         }

  1134         return retvalue;