1 /*

     2  * Copyright (c) 2002, 2016, 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 <X11/Xlib.h>

    27 #include <X11/Xutil.h>

    28 #include <X11/Xos.h>

    29 #include <X11/Xatom.h>

    30 #ifdef __linux__

    31 #include <execinfo.h>

    32 #endif

    33 

    34 #include <jvm.h>

    35 #include <jni.h>

    36 #include <jlong.h>

    37 #include <jni_util.h>

    38 

    39 #include "awt_p.h"

    40 #include "awt_Component.h"

    41 #include "awt_MenuComponent.h"

    42 #include "awt_Font.h"

    43 #include "awt_util.h"

    44 

    45 #include "sun_awt_X11_XToolkit.h"

    46 #include "java_awt_SystemColor.h"

    47 #include "java_awt_TrayIcon.h"

    48 #include <X11/extensions/XTest.h>

    49 

    50 #include <unistd.h>

    51 

    52 uint32_t awt_NumLockMask = 0;

    53 Boolean  awt_ModLockIsShiftLock = False;

    54 

    55 static int32_t num_buttons = 0;

    56 int32_t getNumButtons();

    57 

    58 extern JavaVM *jvm;

    59 

    60 // Tracing level

    61 static int tracing = 0;

    62 #ifdef PRINT

    63 #undef PRINT

    64 #endif

    65 #ifdef PRINT2

    66 #undef PRINT2

    67 #endif

    68 

    69 #define PRINT if (tracing) printf

    70 #define PRINT2 if (tracing > 1) printf

    71 

    72 

    73 struct ComponentIDs componentIDs;

    74 

    75 struct MenuComponentIDs menuComponentIDs;

    76 

    77 #ifndef HEADLESS

    78 

    79 extern Display* awt_init_Display(JNIEnv *env, jobject this);

    80 extern void freeNativeStringArray(char **array, jsize length);

    81 extern char** stringArrayToNative(JNIEnv *env, jobjectArray array, jsize * ret_length);

    82 

    83 struct XFontPeerIDs xFontPeerIDs;

    84 

    85 JNIEXPORT void JNICALL

    86 Java_sun_awt_X11_XFontPeer_initIDs

    87   (JNIEnv *env, jclass cls)

    88 {

    89     xFontPeerIDs.xfsname =

    90       (*env)->GetFieldID(env, cls, "xfsname", "Ljava/lang/String;");

    91 }

    92 #endif /* !HEADLESS */

    93 

    94 /* This function gets called from the static initializer for FileDialog.java

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

    96 

    97 JNIEXPORT void JNICALL

    98 Java_java_awt_FileDialog_initIDs

    99   (JNIEnv *env, jclass cls)

   100 {

   101 

   102 }

   103 

   104 JNIEXPORT void JNICALL

   105 Java_sun_awt_X11_XToolkit_initIDs

   106   (JNIEnv *env, jclass clazz)

   107 {

   108     jfieldID fid = (*env)->GetStaticFieldID(env, clazz, "numLockMask", "I");

   109     CHECK_NULL(fid);

   110     awt_NumLockMask = (*env)->GetStaticIntField(env, clazz, fid);

   111     DTRACE_PRINTLN1("awt_NumLockMask = %u", awt_NumLockMask);

   112     fid = (*env)->GetStaticFieldID(env, clazz, "modLockIsShiftLock", "I");

   113     CHECK_NULL(fid);

   114     awt_ModLockIsShiftLock = (*env)->GetStaticIntField(env, clazz, fid) != 0 ? True : False;

   115 }

   116 

   117 /*

   118  * Class:     sun_awt_X11_XToolkit

   119  * Method:    getTrayIconDisplayTimeout

   120  * Signature: ()J

   121  */

   122 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XToolkit_getTrayIconDisplayTimeout

   123   (JNIEnv *env, jclass clazz)

   124 {

   125     return (jlong) 2000;

   126 }

   127 

   128 /*

   129  * Class:     sun_awt_X11_XToolkit

   130  * Method:    getDefaultXColormap

   131  * Signature: ()J

   132  */

   133 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XToolkit_getDefaultXColormap

   134   (JNIEnv *env, jclass clazz)

   135 {

   136     AwtGraphicsConfigDataPtr defaultConfig =

   137         getDefaultConfig(DefaultScreen(awt_display));

   138 

   139     return (jlong) defaultConfig->awt_cmap;

   140 }

   141 

   142 JNIEXPORT jlong JNICALL Java_sun_awt_X11_XToolkit_getDefaultScreenData

   143   (JNIEnv *env, jclass clazz)

   144 {

   145     return ptr_to_jlong(getDefaultConfig(DefaultScreen(awt_display)));

   146 }

   147 

   148 

   149 JNIEXPORT jint JNICALL

   150 DEF_JNI_OnLoad(JavaVM *vm, void *reserved)

   151 {

   152     jvm = vm;

   153     return JNI_VERSION_1_2;

   154 }

   155 

   156 /*

   157  * Class:     sun_awt_X11_XToolkit

   158  * Method:    nativeLoadSystemColors

   159  * Signature: ([I)V

   160  */

   161 JNIEXPORT void JNICALL Java_sun_awt_X11_XToolkit_nativeLoadSystemColors

   162   (JNIEnv *env, jobject this, jintArray systemColors)

   163 {

   164     AwtGraphicsConfigDataPtr defaultConfig =

   165         getDefaultConfig(DefaultScreen(awt_display));

   166     awtJNI_CreateColorData(env, defaultConfig, 1);

   167 }

   168 

   169 JNIEXPORT void JNICALL

   170 Java_java_awt_Component_initIDs

   171   (JNIEnv *env, jclass cls)

   172 {

   173     jclass keyclass = NULL;

   174 

   175 

   176     componentIDs.x = (*env)->GetFieldID(env, cls, "x", "I");

   177     CHECK_NULL(componentIDs.x);

   178     componentIDs.y = (*env)->GetFieldID(env, cls, "y", "I");

   179     CHECK_NULL(componentIDs.y);

   180     componentIDs.width = (*env)->GetFieldID(env, cls, "width", "I");

   181     CHECK_NULL(componentIDs.width);

   182     componentIDs.height = (*env)->GetFieldID(env, cls, "height", "I");

   183     CHECK_NULL(componentIDs.height);

   184     componentIDs.isPacked = (*env)->GetFieldID(env, cls, "isPacked", "Z");

   185     CHECK_NULL(componentIDs.isPacked);

   186     componentIDs.peer =

   187       (*env)->GetFieldID(env, cls, "peer", "Ljava/awt/peer/ComponentPeer;");

   188     CHECK_NULL(componentIDs.peer);

   189     componentIDs.background =

   190       (*env)->GetFieldID(env, cls, "background", "Ljava/awt/Color;");

   191     CHECK_NULL(componentIDs.background);

   192     componentIDs.foreground =

   193       (*env)->GetFieldID(env, cls, "foreground", "Ljava/awt/Color;");

   194     CHECK_NULL(componentIDs.foreground);

   195     componentIDs.graphicsConfig =

   196         (*env)->GetFieldID(env, cls, "graphicsConfig",

   197                            "Ljava/awt/GraphicsConfiguration;");

   198     CHECK_NULL(componentIDs.graphicsConfig);

   199     componentIDs.name =

   200       (*env)->GetFieldID(env, cls, "name", "Ljava/lang/String;");

   201     CHECK_NULL(componentIDs.name);

   202 

   203     /* Use _NoClientCode() methods for trusted methods, so that we

   204      *  know that we are not invoking client code on trusted threads

   205      */

   206     componentIDs.getParent =

   207       (*env)->GetMethodID(env, cls, "getParent_NoClientCode",

   208                          "()Ljava/awt/Container;");

   209     CHECK_NULL(componentIDs.getParent);

   210 

   211     componentIDs.getLocationOnScreen =

   212       (*env)->GetMethodID(env, cls, "getLocationOnScreen_NoTreeLock",

   213                          "()Ljava/awt/Point;");

   214     CHECK_NULL(componentIDs.getLocationOnScreen);

   215 

   216     keyclass = (*env)->FindClass(env, "java/awt/event/KeyEvent");

   217     CHECK_NULL(keyclass);

   218 

   219     componentIDs.isProxyActive =

   220         (*env)->GetFieldID(env, keyclass, "isProxyActive",

   221                            "Z");

   222     CHECK_NULL(componentIDs.isProxyActive);

   223 

   224     componentIDs.appContext =

   225         (*env)->GetFieldID(env, cls, "appContext",

   226                            "Lsun/awt/AppContext;");

   227 

   228     (*env)->DeleteLocalRef(env, keyclass);

   229 }

   230 

   231 

   232 JNIEXPORT void JNICALL

   233 Java_java_awt_Container_initIDs

   234   (JNIEnv *env, jclass cls)

   235 {

   236 

   237 }

   238 

   239 

   240 JNIEXPORT void JNICALL

   241 Java_java_awt_Button_initIDs

   242   (JNIEnv *env, jclass cls)

   243 {

   244 

   245 }

   246 

   247 JNIEXPORT void JNICALL

   248 Java_java_awt_Scrollbar_initIDs

   249   (JNIEnv *env, jclass cls)

   250 {

   251 

   252 }

   253 

   254 

   255 JNIEXPORT void JNICALL

   256 Java_java_awt_Window_initIDs

   257   (JNIEnv *env, jclass cls)

   258 {

   259 

   260 }

   261 

   262 JNIEXPORT void JNICALL

   263 Java_java_awt_Frame_initIDs

   264   (JNIEnv *env, jclass cls)

   265 {

   266 

   267 }

   268 

   269 

   270 JNIEXPORT void JNICALL

   271 Java_java_awt_MenuComponent_initIDs(JNIEnv *env, jclass cls)

   272 {

   273     menuComponentIDs.appContext =

   274       (*env)->GetFieldID(env, cls, "appContext", "Lsun/awt/AppContext;");

   275 }

   276 

   277 JNIEXPORT void JNICALL

   278 Java_java_awt_Cursor_initIDs(JNIEnv *env, jclass cls)

   279 {

   280 }

   281 

   282 

   283 JNIEXPORT void JNICALL Java_java_awt_MenuItem_initIDs

   284   (JNIEnv *env, jclass cls)

   285 {

   286 }

   287 

   288 

   289 JNIEXPORT void JNICALL Java_java_awt_Menu_initIDs

   290   (JNIEnv *env, jclass cls)

   291 {

   292 }

   293 

   294 JNIEXPORT void JNICALL

   295 Java_java_awt_TextArea_initIDs

   296   (JNIEnv *env, jclass cls)

   297 {

   298 }

   299 

   300 

   301 JNIEXPORT void JNICALL

   302 Java_java_awt_Checkbox_initIDs

   303   (JNIEnv *env, jclass cls)

   304 {

   305 }

   306 

   307 

   308 JNIEXPORT void JNICALL Java_java_awt_ScrollPane_initIDs

   309   (JNIEnv *env, jclass cls)

   310 {

   311 }

   312 

   313 JNIEXPORT void JNICALL

   314 Java_java_awt_TextField_initIDs

   315   (JNIEnv *env, jclass cls)

   316 {

   317 }

   318 

   319 JNIEXPORT jboolean JNICALL AWTIsHeadless() {

   320 #ifdef HEADLESS

   321     return JNI_TRUE;

   322 #else

   323     return JNI_FALSE;

   324 #endif

   325 }

   326 

   327 JNIEXPORT void JNICALL Java_java_awt_Dialog_initIDs (JNIEnv *env, jclass cls)

   328 {

   329 }

   330 

   331 

   332 /* ========================== Begin poll section ================================ */

   333 

   334 // Includes

   335 

   336 #include <sys/time.h>

   337 #include <limits.h>

   338 #include <locale.h>

   339 #include <pthread.h>

   340 

   341 #include <dlfcn.h>

   342 #include <fcntl.h>

   343 

   344 #include <poll.h>

   345 #ifndef POLLRDNORM

   346 #define POLLRDNORM POLLIN

   347 #endif

   348 

   349 // Prototypes

   350 

   351 static void     waitForEvents(JNIEnv *, jlong);

   352 static void     awt_pipe_init();

   353 static Boolean  performPoll(JNIEnv *, jlong);

   354 static void     wakeUp();

   355 static void     update_poll_timeout(int timeout_control);

   356 static uint32_t get_poll_timeout(jlong nextTaskTime);

   357 

   358 // Defines

   359 

   360 #ifndef bzero

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

   362 #endif

   363 

   364 #define AWT_POLL_BUFSIZE        100 /* bytes */

   365 #define AWT_READPIPE            (awt_pipe_fds[0])

   366 #define AWT_WRITEPIPE           (awt_pipe_fds[1])

   367 

   368 #define DEF_AWT_MAX_POLL_TIMEOUT ((uint32_t)500) /* milliseconds */

   369 #define DEF_AWT_FLUSH_TIMEOUT ((uint32_t)100) /* milliseconds */

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

   371 

   372 #define TIMEOUT_TIMEDOUT 0

   373 #define TIMEOUT_EVENTS 1

   374 

   375 /* awt_poll_alg - AWT Poll Events Aging Algorithms */

   376 #define AWT_POLL_FALSE        1

   377 #define AWT_POLL_AGING_SLOW   2

   378 #define AWT_POLL_AGING_FAST   3

   379 

   380 #define AWT_POLL_THRESHOLD 1000  // msec, Block if delay is larger

   381 #define AWT_POLL_BLOCK       -1  // cause poll() block

   382 

   383 // Static fields

   384 

   385 static int          awt_poll_alg = AWT_POLL_AGING_SLOW;

   386 

   387 static uint32_t AWT_FLUSH_TIMEOUT  =  DEF_AWT_FLUSH_TIMEOUT; /* milliseconds */

   388 static uint32_t AWT_MAX_POLL_TIMEOUT = DEF_AWT_MAX_POLL_TIMEOUT; /* milliseconds */

   389 static pthread_t    awt_MainThread = 0;

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

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

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

   393 static jlong        awt_last_flush_time = 0LL; /* 0 == no scheduled flush */

   394 static uint32_t     curPollTimeout;

   395 static struct pollfd pollFds[2];

   396 static jlong        poll_sleep_time = 0LL; // Used for tracing

   397 static jlong        poll_wakeup_time = 0LL; // Used for tracing

   398 

   399 // AWT static poll timeout.  Zero means "not set", aging algorithm is

   400 // used.  Static poll timeout values higher than 50 cause application

   401 // look "slow" - they don't respond to user request fast

   402 // enough. Static poll timeout value less than 10 are usually

   403 // considered by schedulers as zero, so this might cause unnecessary

   404 // CPU consumption by Java.  The values between 10 - 50 are suggested

   405 // for single client desktop configurations.  For SunRay servers, it

   406 // is highly recomended to use aging algorithm (set static poll timeout

   407 // to 0).

   408 static int32_t static_poll_timeout = 0;

   409 

   410 static Bool isMainThread() {

   411     return awt_MainThread == pthread_self();

   412 }

   413 

   414 /*

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

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

   417  * select() by writing to this pipe.

   418  */

   419 static void

   420 awt_pipe_init() {

   421 

   422     if (awt_pipe_inited) {

   423         return;

   424     }

   425 

   426     if ( pipe ( awt_pipe_fds ) == 0 )

   427     {

   428         /*

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

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

   431         ** flush.

   432         */

   433         int32_t flags = 0;

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

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

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

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

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

   439         awt_pipe_inited = True;

   440     }

   441     else

   442     {

   443         AWT_READPIPE = -1;

   444         AWT_WRITEPIPE = -1;

   445     }

   446 

   447 

   448 } /* awt_pipe_init() */

   449 

   450 /**

   451  * Reads environment variables to initialize timeout fields.

   452  */

   453 static void readEnv() {

   454     char * value;

   455     int tmp_poll_alg;

   456     static Boolean env_read = False;

   457     if (env_read) return;

   458 

   459     env_read = True;

   460 

   461     value = getenv("_AWT_MAX_POLL_TIMEOUT");

   462     if (value != NULL) {

   463         AWT_MAX_POLL_TIMEOUT = atoi(value);

   464         if (AWT_MAX_POLL_TIMEOUT == 0) {

   465             AWT_MAX_POLL_TIMEOUT = DEF_AWT_MAX_POLL_TIMEOUT;

   466         }

   467     }

   468     curPollTimeout = AWT_MAX_POLL_TIMEOUT/2;

   469 

   470     value = getenv("_AWT_FLUSH_TIMEOUT");

   471     if (value != NULL) {

   472         AWT_FLUSH_TIMEOUT = atoi(value);

   473         if (AWT_FLUSH_TIMEOUT == 0) {

   474             AWT_FLUSH_TIMEOUT = DEF_AWT_FLUSH_TIMEOUT;

   475         }

   476     }

   477 

   478     value = getenv("_AWT_POLL_TRACING");

   479     if (value != NULL) {

   480         tracing = atoi(value);

   481     }

   482 

   483     value = getenv("_AWT_STATIC_POLL_TIMEOUT");

   484     if (value != NULL) {

   485         static_poll_timeout = atoi(value);

   486     }

   487     if (static_poll_timeout != 0) {

   488         curPollTimeout = static_poll_timeout;

   489     }

   490 

   491     // non-blocking poll()

   492     value = getenv("_AWT_POLL_ALG");

   493     if (value != NULL) {

   494         tmp_poll_alg = atoi(value);

   495         switch(tmp_poll_alg) {

   496         case AWT_POLL_FALSE:

   497         case AWT_POLL_AGING_SLOW:

   498         case AWT_POLL_AGING_FAST:

   499             awt_poll_alg = tmp_poll_alg;

   500             break;

   501         default:

   502             PRINT("Unknown value of _AWT_POLL_ALG, assuming Slow Aging Algorithm by default");

   503             awt_poll_alg = AWT_POLL_AGING_SLOW;

   504             break;

   505         }

   506     }

   507 }

   508 

   509 /**

   510  * Returns the amount of milliseconds similar to System.currentTimeMillis()

   511  */

   512 static jlong

   513 awtJNI_TimeMillis(void)

   514 {

   515     struct timeval t;

   516 

   517     gettimeofday(&t, 0);

   518 

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

   520              jint_to_jlong(t.tv_usec / 1000));

   521 }

   522 

   523 /**

   524  * Updates curPollTimeout according to the aging algorithm.

   525  * @param timeout_control Either TIMEOUT_TIMEDOUT or TIMEOUT_EVENTS

   526  */

   527 static void update_poll_timeout(int timeout_control) {

   528     PRINT2("tout: %d\n", timeout_control);

   529 

   530     // If static_poll_timeout is set, curPollTimeout has the fixed value

   531     if (static_poll_timeout != 0) return;

   532 

   533     // Update it otherwise

   534 

   535     switch(awt_poll_alg) {

   536     case AWT_POLL_AGING_SLOW:

   537         if (timeout_control == TIMEOUT_TIMEDOUT) {

   538             /* add 1/4 (plus 1, in case the division truncates to 0) */

   539             curPollTimeout += ((curPollTimeout>>2) + 1);

   540             curPollTimeout = min(AWT_MAX_POLL_TIMEOUT, curPollTimeout);

   541         } else if (timeout_control == TIMEOUT_EVENTS) {

   542             /* subtract 1/4 (plus 1, in case the division truncates to 0) */

   543             if (curPollTimeout > 0) {

   544                 curPollTimeout -= ((curPollTimeout>>2) + 1);

   545                 curPollTimeout = max(AWT_MIN_POLL_TIMEOUT, curPollTimeout);

   546             }

   547         }

   548         break;

   549     case AWT_POLL_AGING_FAST:

   550         if (timeout_control == TIMEOUT_TIMEDOUT) {

   551             curPollTimeout += ((curPollTimeout>>2) + 1);

   552             curPollTimeout = min(AWT_MAX_POLL_TIMEOUT, curPollTimeout);

   553             if((int)curPollTimeout > AWT_POLL_THRESHOLD || (int)curPollTimeout == AWT_POLL_BLOCK)

   554                 curPollTimeout = AWT_POLL_BLOCK;

   555         } else if (timeout_control == TIMEOUT_EVENTS) {

   556             curPollTimeout = max(AWT_MIN_POLL_TIMEOUT, 1);

   557         }

   558         break;

   559     }

   560 }

   561 

   562 /*

   563  * Gets the best timeout for the next call to poll().

   564  *

   565  * @param nextTaskTime -1, if there are no tasks; next time when

   566  * timeout task needs to be run, in millis(of currentTimeMillis)

   567  */

   568 static uint32_t get_poll_timeout(jlong nextTaskTime)

   569 {

   570     uint32_t ret_timeout = 0;

   571     uint32_t timeout;

   572     uint32_t taskTimeout;

   573     uint32_t flushTimeout;

   574 

   575     jlong curTime = awtJNI_TimeMillis();

   576     timeout = curPollTimeout;

   577     switch(awt_poll_alg) {

   578     case AWT_POLL_AGING_SLOW:

   579     case AWT_POLL_AGING_FAST:

   580         taskTimeout = (nextTaskTime == -1) ? AWT_MAX_POLL_TIMEOUT : (uint32_t)max(0, (int32_t)(nextTaskTime - curTime));

   581         flushTimeout = (awt_next_flush_time > 0) ? (uint32_t)max(0, (int32_t)(awt_next_flush_time - curTime)) : AWT_MAX_POLL_TIMEOUT;

   582 

   583         PRINT2("to: %d, ft: %d, to: %d, tt: %d, mil: %d\n", taskTimeout, flushTimeout, timeout, (int)nextTaskTime, (int)curTime);

   584 

   585         // Adjust timeout to flush_time and task_time

   586         ret_timeout = min(flushTimeout, min(taskTimeout, timeout));

   587         if((int)curPollTimeout == AWT_POLL_BLOCK)

   588            ret_timeout = AWT_POLL_BLOCK;

   589         break;

   590 

   591     case AWT_POLL_FALSE:

   592         ret_timeout = (nextTaskTime > curTime) ?

   593             (nextTaskTime - curTime) :

   594             ((nextTaskTime == -1) ? -1 : 0);

   595         break;

   596     }

   597 

   598     return ret_timeout;

   599 

   600 } /* get_poll_timeout() */

   601 

   602 /*

   603  * Waits for X events to appear on the pipe. Returns only when

   604  * it is likely (but not definite) that there are events waiting to

   605  * be processed.

   606  *

   607  * This routine also flushes the outgoing X queue, when the

   608  * awt_next_flush_time has been reached.

   609  *

   610  * If fdAWTPipe is greater or equal than zero the routine also

   611  * checks if there are events pending on the putback queue.

   612  */

   613 void

   614 waitForEvents(JNIEnv *env, jlong nextTaskTime) {

   615     if (performPoll(env, nextTaskTime)

   616           && (awt_next_flush_time > 0)

   617           && (awtJNI_TimeMillis() >= awt_next_flush_time)) {

   618 

   619                 XFlush(awt_display);

   620                 awt_last_flush_time = awt_next_flush_time;

   621                 awt_next_flush_time = 0LL;

   622     }

   623 } /* waitForEvents() */

   624 

   625 JNIEXPORT void JNICALL Java_sun_awt_X11_XToolkit_waitForEvents (JNIEnv *env, jclass class, jlong nextTaskTime) {

   626     waitForEvents(env, nextTaskTime);

   627 }

   628 

   629 JNIEXPORT void JNICALL Java_sun_awt_X11_XToolkit_awt_1toolkit_1init (JNIEnv *env, jclass class) {

   630     awt_MainThread = pthread_self();

   631 

   632     awt_pipe_init();

   633     readEnv();

   634 }

   635 

   636 JNIEXPORT void JNICALL Java_sun_awt_X11_XToolkit_awt_1output_1flush (JNIEnv *env, jclass class) {

   637     awt_output_flush();

   638 }

   639 

   640 JNIEXPORT void JNICALL Java_sun_awt_X11_XToolkit_wakeup_1poll (JNIEnv *env, jclass class) {

   641     wakeUp();

   642 }

   643 

   644 /*

   645  * Polls both the X pipe and our AWT utility pipe. Returns

   646  * when there is data on one of the pipes, or the operation times

   647  * out.

   648  *

   649  * Not all Xt events come across the X pipe (e.g., timers

   650  * and alternate inputs), so we must time out every now and

   651  * then to check the Xt event queue.

   652  *

   653  * The fdAWTPipe will be empty when this returns.

   654  */

   655 static Boolean

   656 performPoll(JNIEnv *env, jlong nextTaskTime) {

   657     static Bool pollFdsInited = False;

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

   659 

   660     uint32_t timeout = get_poll_timeout(nextTaskTime);

   661     int32_t result;

   662 

   663     if (!pollFdsInited) {

   664         pollFds[0].fd = ConnectionNumber(awt_display);

   665         pollFds[0].events = POLLRDNORM;

   666         pollFds[0].revents = 0;

   667 

   668         pollFds[1].fd = AWT_READPIPE;

   669         pollFds[1].events = POLLRDNORM;

   670         pollFds[1].revents = 0;

   671         pollFdsInited = True;

   672     } else {

   673         pollFds[0].revents = 0;

   674         pollFds[1].revents = 0;

   675     }

   676 

   677     AWT_NOFLUSH_UNLOCK();

   678 

   679     /* ACTUALLY DO THE POLL() */

   680     if (timeout == 0) {

   681         // be sure other threads get a chance

   682         if (!awtJNI_ThreadYield(env)) {

   683             return FALSE;

   684         }

   685     }

   686 

   687     if (tracing) poll_sleep_time = awtJNI_TimeMillis();

   688     result = poll( pollFds, 2, (int32_t) timeout );

   689     if (tracing) poll_wakeup_time = awtJNI_TimeMillis();

   690     PRINT("%d of %d, res: %d\n", (int)(poll_wakeup_time-poll_sleep_time), (int)timeout, result);

   691 

   692     AWT_LOCK();

   693     if (result == 0) {

   694         /* poll() timed out -- update timeout value */

   695         update_poll_timeout(TIMEOUT_TIMEDOUT);

   696         PRINT2("performPoll(): TIMEOUT_TIMEDOUT curPollTimeout = %d \n", curPollTimeout);

   697     }

   698     if (pollFds[1].revents) {

   699         int count;

   700         PRINT("Woke up\n");

   701         /* There is data on the AWT pipe - empty it */

   702         do {

   703             count = read(AWT_READPIPE, read_buf, AWT_POLL_BUFSIZE );

   704         } while (count == AWT_POLL_BUFSIZE );

   705         PRINT2("performPoll():  data on the AWT pipe: curPollTimeout = %d \n", curPollTimeout);

   706     }

   707     if (pollFds[0].revents) {

   708         // Events in X pipe

   709         update_poll_timeout(TIMEOUT_EVENTS);

   710         PRINT2("performPoll(): TIMEOUT_EVENTS curPollTimeout = %d \n", curPollTimeout);

   711     }

   712     return TRUE;

   713 

   714 } /* performPoll() */

   715 

   716 /**

   717  * Schedules next auto-flush event or performs forced flush depending

   718  * on the time of the previous flush.

   719  */

   720 void awt_output_flush() {

   721     if (awt_next_flush_time == 0) {

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

   723 

   724         jlong curTime = awtJNI_TimeMillis(); // current time

   725         jlong l_awt_last_flush_time = awt_last_flush_time; // last time we flushed queue

   726         jlong next_flush_time = l_awt_last_flush_time + AWT_FLUSH_TIMEOUT;

   727 

   728         if (curTime >= next_flush_time) {

   729             // Enough time passed from last flush

   730             PRINT("f1\n");

   731             AWT_LOCK();

   732             XFlush(awt_display);

   733             awt_last_flush_time = curTime;

   734             AWT_NOFLUSH_UNLOCK();

   735         } else {

   736             awt_next_flush_time = next_flush_time;

   737             PRINT("f2\n");

   738             wakeUp();

   739         }

   740     }

   741 }

   742 

   743 

   744 /**

   745  * Wakes-up poll() in performPoll

   746  */

   747 static void wakeUp() {

   748     static char wakeUp_char = 'p';

   749     if (!isMainThread() && awt_pipe_inited) {

   750         write ( AWT_WRITEPIPE, &wakeUp_char, 1 );

   751     }

   752 }

   753 

   754 

   755 /* ========================== End poll section ================================= */

   756 

   757 /*

   758  * Class:     java_awt_KeyboardFocusManager

   759  * Method:    initIDs

   760  * Signature: ()V

   761  */

   762 JNIEXPORT void JNICALL

   763 Java_java_awt_KeyboardFocusManager_initIDs

   764     (JNIEnv *env, jclass cls)

   765 {

   766 }

   767 

   768 /*

   769  * Class:     sun_awt_X11_XToolkit

   770  * Method:    getEnv

   771  * Signature: (Ljava/lang/String;)Ljava/lang/String;

   772  */

   773 JNIEXPORT jstring JNICALL Java_sun_awt_X11_XToolkit_getEnv

   774 (JNIEnv *env , jclass clazz, jstring key) {

   775     char *ptr = NULL;

   776     const char *keystr = NULL;

   777     jstring ret = NULL;

   778 

   779     keystr = JNU_GetStringPlatformChars(env, key, NULL);

   780     if (keystr) {

   781         ptr = getenv(keystr);

   782         if (ptr) {

   783             ret = JNU_NewStringPlatform(env, (const char *) ptr);

   784         }

   785         JNU_ReleaseStringPlatformChars(env, key, (const char*)keystr);

   786     }

   787     return ret;

   788 }

   789 

   790 #ifdef __linux__

   791 void print_stack(void)

   792 {

   793   void *array[10];

   794   size_t size;

   795   char **strings;

   796   size_t i;

   797 

   798   size = backtrace (array, 10);

   799   strings = backtrace_symbols (array, size);

   800 

   801   fprintf (stderr, "Obtained %zd stack frames.\n", size);

   802 

   803   for (i = 0; i < size; i++)

   804      fprintf (stderr, "%s\n", strings[i]);

   805 

   806   free (strings);

   807 }

   808 #endif

   809 

   810 Window get_xawt_root_shell(JNIEnv *env) {

   811   static jclass classXRootWindow = NULL;

   812   static jmethodID methodGetXRootWindow = NULL;

   813   static Window xawt_root_shell = None;

   814 

   815   if (xawt_root_shell == None){

   816       if (classXRootWindow == NULL){

   817           jclass cls_tmp = (*env)->FindClass(env, "sun/awt/X11/XRootWindow");

   818           if (!JNU_IsNull(env, cls_tmp)) {

   819               classXRootWindow = (jclass)(*env)->NewGlobalRef(env, cls_tmp);

   820               (*env)->DeleteLocalRef(env, cls_tmp);

   821           }

   822       }

   823       if( classXRootWindow != NULL) {

   824           methodGetXRootWindow = (*env)->GetStaticMethodID(env, classXRootWindow, "getXRootWindow", "()J");

   825       }

   826       if( classXRootWindow != NULL && methodGetXRootWindow !=NULL ) {

   827           xawt_root_shell = (Window) (*env)->CallStaticLongMethod(env, classXRootWindow, methodGetXRootWindow);

   828       }

   829       if ((*env)->ExceptionCheck(env)) {

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

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

   832       }

   833   }

   834   return xawt_root_shell;

   835 }

   836 

   837 /*

   838  * Old, compatibility, backdoor for DT.  This is a different

   839  * implementation.  It keeps the signature, but acts on

   840  * awt_root_shell, not the frame passed as an argument.  Note, that

   841  * the code that uses the old backdoor doesn't work correctly with

   842  * gnome session proxy that checks for WM_COMMAND when the window is

   843  * firts mapped, because DT code calls this old backdoor *after* the

   844  * frame is shown or it would get NPE with old AWT (previous

   845  * implementation of this backdoor) otherwise.  Old style session

   846  * managers (e.g. CDE) that check WM_COMMAND only during session

   847  * checkpoint should work fine, though.

   848  *

   849  * NB: The function name looks deceptively like a JNI native method

   850  * name.  It's not!  It's just a plain function.

   851  */

   852 

   853 JNIEXPORT void JNICALL

   854 Java_sun_awt_motif_XsessionWMcommand(JNIEnv *env, jobject this,

   855     jobject frame, jstring jcommand)

   856 {

   857     const char *command;

   858     XTextProperty text_prop;

   859     char *c[1];

   860     int32_t status;

   861     Window xawt_root_window;

   862 

   863     AWT_LOCK();

   864     xawt_root_window = get_xawt_root_shell(env);

   865 

   866     if ( xawt_root_window == None ) {

   867         AWT_UNLOCK();

   868         JNU_ThrowNullPointerException(env, "AWT root shell is unrealized");

   869         return;

   870     }

   871 

   872     command = (char *) JNU_GetStringPlatformChars(env, jcommand, NULL);

   873     if (command != NULL) {

   874         c[0] = (char *)command;

   875         status = XmbTextListToTextProperty(awt_display, c, 1,

   876                                            XStdICCTextStyle, &text_prop);

   877 

   878         if (status == Success || status > 0) {

   879             XSetTextProperty(awt_display, xawt_root_window,

   880                              &text_prop, XA_WM_COMMAND);

   881             if (text_prop.value != NULL)

   882                 XFree(text_prop.value);

   883         }

   884         JNU_ReleaseStringPlatformChars(env, jcommand, command);

   885     }

   886     AWT_UNLOCK();

   887 }

   888 

   889 

   890 /*

   891  * New DT backdoor to set WM_COMMAND.  New code should use this

   892  * backdoor and call it *before* the first frame is shown so that

   893  * gnome session proxy can correctly handle it.

   894  *

   895  * NB: The function name looks deceptively like a JNI native method

   896  * name.  It's not!  It's just a plain function.

   897  */

   898 JNIEXPORT void JNICALL

   899 Java_sun_awt_motif_XsessionWMcommand_New(JNIEnv *env, jobjectArray jarray)

   900 {

   901     jsize length;

   902     char ** array;

   903     XTextProperty text_prop;

   904     int status;

   905     Window xawt_root_window;

   906 

   907     AWT_LOCK();

   908     xawt_root_window = get_xawt_root_shell(env);

   909 

   910     if (xawt_root_window == None) {

   911       AWT_UNLOCK();

   912       JNU_ThrowNullPointerException(env, "AWT root shell is unrealized");

   913       return;

   914     }

   915 

   916     array = stringArrayToNative(env, jarray, &length);

   917 

   918     if (array != NULL) {

   919         status = XmbTextListToTextProperty(awt_display, array, length,

   920                                            XStdICCTextStyle, &text_prop);

   921         if (status < 0) {

   922             switch (status) {

   923             case XNoMemory:

   924                 JNU_ThrowOutOfMemoryError(env,

   925                     "XmbTextListToTextProperty: XNoMemory");

   926                 break;

   927             case XLocaleNotSupported:

   928                 JNU_ThrowInternalError(env,

   929                     "XmbTextListToTextProperty: XLocaleNotSupported");

   930                 break;

   931             case XConverterNotFound:

   932                 JNU_ThrowNullPointerException(env,

   933                     "XmbTextListToTextProperty: XConverterNotFound");

   934                 break;

   935             default:

   936                 JNU_ThrowInternalError(env,

   937                     "XmbTextListToTextProperty: unknown error");

   938             }

   939         } else {

   940             XSetTextProperty(awt_display, xawt_root_window,

   941                                  &text_prop, XA_WM_COMMAND);

   942         }

   943 

   944         if (text_prop.value != NULL)

   945             XFree(text_prop.value);

   946 

   947         freeNativeStringArray(array, length);

   948     }

   949     AWT_UNLOCK();

   950 }

   951 

   952 /*

   953  * Class:     java_awt_TrayIcon

   954  * Method:    initIDs

   955  * Signature: ()V

   956  */

   957 JNIEXPORT void JNICALL Java_java_awt_TrayIcon_initIDs(JNIEnv *env , jclass clazz)

   958 {

   959 }

   960 

   961 

   962 /*

   963  * Class:     java_awt_Cursor

   964  * Method:    finalizeImpl

   965  * Signature: ()V

   966  */

   967 JNIEXPORT void JNICALL

   968 Java_java_awt_Cursor_finalizeImpl(JNIEnv *env, jclass clazz, jlong pData)

   969 {

   970     Cursor xcursor;

   971 

   972     xcursor = (Cursor)pData;

   973     if (xcursor != None) {

   974         AWT_LOCK();

   975         XFreeCursor(awt_display, xcursor);

   976         AWT_UNLOCK();

   977     }

   978 }

   979 

   980 

   981 /*

   982  * Class:     sun_awt_X11_XToolkit

   983  * Method:    getNumberOfButtonsImpl

   984  * Signature: ()I

   985  */

   986 JNIEXPORT jint JNICALL Java_sun_awt_X11_XToolkit_getNumberOfButtonsImpl

   987 (JNIEnv * env, jobject cls){

   988     if (num_buttons == 0) {

   989         num_buttons = getNumButtons();

   990     }

   991     return num_buttons;

   992 }

   993 

   994 int32_t getNumButtons() {

   995     int32_t major_opcode, first_event, first_error;

   996     int32_t xinputAvailable;

   997     int32_t numDevices, devIdx, clsIdx;

   998     XDeviceInfo* devices;

   999     XDeviceInfo* aDevice;

  1000     XButtonInfo* bInfo;

  1001     int32_t local_num_buttons = 0;

  1002 

  1003     /* 4700242:

  1004      * If XTest is asked to press a non-existant mouse button

  1005      * (i.e. press Button3 on a system configured with a 2-button mouse),

  1006      * then a crash may happen.  To avoid this, we use the XInput

  1007      * extension to query for the number of buttons on the XPointer, and check

  1008      * before calling XTestFakeButtonEvent().

  1009      */

  1010     xinputAvailable = XQueryExtension(awt_display, INAME, &major_opcode, &first_event, &first_error);

  1011     if (xinputAvailable) {

  1012         DTRACE_PRINTLN3("RobotPeer: XQueryExtension(XINPUT) returns major_opcode = %d, first_event = %d, first_error = %d",

  1013                         major_opcode, first_event, first_error);

  1014         devices = XListInputDevices(awt_display, &numDevices);

  1015         for (devIdx = 0; devIdx < numDevices; devIdx++) {

  1016             aDevice = &(devices[devIdx]);

  1017 #ifdef IsXExtensionPointer

  1018             if (aDevice->use == IsXExtensionPointer) {

  1019                 for (clsIdx = 0; clsIdx < aDevice->num_classes; clsIdx++) {

  1020                     if (aDevice->inputclassinfo[clsIdx].class == ButtonClass) {

  1021                         bInfo = (XButtonInfo*)(&(aDevice->inputclassinfo[clsIdx]));

  1022                         local_num_buttons = bInfo->num_buttons;

  1023                         DTRACE_PRINTLN1("RobotPeer: XPointer has %d buttons", num_buttons);

  1024                         break;

  1025                     }

  1026                 }

  1027                 break;

  1028             }

  1029 #endif

  1030             if (local_num_buttons <= 0 ) {

  1031                 if (aDevice->use == IsXPointer) {

  1032                     for (clsIdx = 0; clsIdx < aDevice->num_classes; clsIdx++) {

  1033                         if (aDevice->inputclassinfo[clsIdx].class == ButtonClass) {

  1034                             bInfo = (XButtonInfo*)(&(aDevice->inputclassinfo[clsIdx]));

  1035                             local_num_buttons = bInfo->num_buttons;

  1036                             DTRACE_PRINTLN1("RobotPeer: XPointer has %d buttons", num_buttons);

  1037                             break;

  1038                         }

  1039                     }

  1040                     break;

  1041                 }

  1042             }

  1043         }

  1044 

  1045         XFreeDeviceList(devices);

  1046     }

  1047     else {

  1048         DTRACE_PRINTLN1("RobotPeer: XINPUT extension is unavailable, assuming %d mouse buttons", num_buttons);

  1049     }

  1050     if (local_num_buttons == 0 ) {

  1051         local_num_buttons = 3;

  1052     }

  1053 

  1054     return local_num_buttons;

  1055 }

  1056 

  1057 /*

  1058  * Class:     sun_awt_X11_XWindowPeer

  1059  * Method:    getJvmPID

  1060  * Signature: ()I

  1061  */

  1062 JNIEXPORT jint JNICALL Java_sun_awt_X11_XWindowPeer_getJvmPID

  1063 (JNIEnv *env, jclass cls)

  1064 {

  1065     /* Return the JVM's PID. */

  1066     return getpid();

  1067 }

  1068 

  1069 #ifndef HOST_NAME_MAX

  1070 #define HOST_NAME_MAX 1024 /* Overestimated */

  1071 #endif

  1072 

  1073 /*

  1074  * Class:     sun_awt_X11_XWindowPeer

  1075  * Method:    getLocalHostname

  1076  * Signature: ()Ljava/lang/String;

  1077  */

  1078 JNIEXPORT jstring JNICALL Java_sun_awt_X11_XWindowPeer_getLocalHostname

  1079 (JNIEnv *env, jclass cls)

  1080 {

  1081     /* Return the machine's FQDN. */

  1082     char hostname[HOST_NAME_MAX + 1];

  1083     if (gethostname(hostname, HOST_NAME_MAX + 1) == 0) {

  1084         hostname[HOST_NAME_MAX] = '\0';

  1085         jstring res = (*env)->NewStringUTF(env, hostname);

  1086         return res;

  1087     }

  1088 

  1089     return (jstring)NULL;

  1090 }