1 /*

     2  * Copyright (c) 1997, 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 #ifdef HEADLESS

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

    28 #endif

    29 

    30 #include <stdio.h>

    31 #include <stdlib.h>

    32 #include <X11/Xlib.h>

    33 #include <X11/keysym.h>

    34 #include <sys/time.h>

    35 

    36 #include "awt.h"

    37 #include "awt_p.h"

    38 

    39 #include <sun_awt_X11InputMethod.h>

    40 #include <sun_awt_X11_XInputMethod.h>

    41 

    42 #define THROW_OUT_OF_MEMORY_ERROR() \

    43         JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), NULL)

    44 

    45 struct X11InputMethodIDs {

    46   jfieldID pData;

    47 } x11InputMethodIDs;

    48 

    49 static void PreeditStartCallback(XIC, XPointer, XPointer);

    50 static void PreeditDoneCallback(XIC, XPointer, XPointer);

    51 static void PreeditDrawCallback(XIC, XPointer,

    52                                 XIMPreeditDrawCallbackStruct *);

    53 static void PreeditCaretCallback(XIC, XPointer,

    54                                  XIMPreeditCaretCallbackStruct *);

    55 #if defined(__linux__) || defined(MACOSX)

    56 static void StatusStartCallback(XIC, XPointer, XPointer);

    57 static void StatusDoneCallback(XIC, XPointer, XPointer);

    58 static void StatusDrawCallback(XIC, XPointer,

    59                                XIMStatusDrawCallbackStruct *);

    60 #endif

    61 

    62 #define ROOT_WINDOW_STYLES      (XIMPreeditNothing | XIMStatusNothing)

    63 #define NO_STYLES               (XIMPreeditNone | XIMStatusNone)

    64 

    65 #define PreeditStartIndex       0

    66 #define PreeditDoneIndex        1

    67 #define PreeditDrawIndex        2

    68 #define PreeditCaretIndex       3

    69 #if defined(__linux__) || defined(MACOSX)

    70 #define StatusStartIndex        4

    71 #define StatusDoneIndex         5

    72 #define StatusDrawIndex         6

    73 #define NCALLBACKS              7

    74 #else

    75 #define NCALLBACKS              4

    76 #endif

    77 

    78 /*

    79  * Callback function pointers: the order has to match the *Index

    80  * values above.

    81  */

    82 static XIMProc callback_funcs[NCALLBACKS] = {

    83     (XIMProc)PreeditStartCallback,

    84     (XIMProc)PreeditDoneCallback,

    85     (XIMProc)PreeditDrawCallback,

    86     (XIMProc)PreeditCaretCallback,

    87 #if defined(__linux__) || defined(MACOSX)

    88     (XIMProc)StatusStartCallback,

    89     (XIMProc)StatusDoneCallback,

    90     (XIMProc)StatusDrawCallback,

    91 #endif

    92 };

    93 

    94 #if defined(__linux__) || defined(MACOSX)

    95 #define MAX_STATUS_LEN  100

    96 typedef struct {

    97     Window   w;                /*status window id        */

    98     Window   root;             /*the root window id      */

    99     Window   parent;           /*parent shell window     */

   100     int      x, y;             /*parent's upperleft position */

   101     int      width, height;    /*parent's width, height  */

   102     GC       lightGC;          /*gc for light border     */

   103     GC       dimGC;            /*gc for dim border       */

   104     GC       bgGC;             /*normal painting         */

   105     GC       fgGC;             /*normal painting         */

   106     int      statusW, statusH; /*status window's w, h    */

   107     int      rootW, rootH;     /*root window's w, h    */

   108     int      bWidth;           /*border width            */

   109     char     status[MAX_STATUS_LEN]; /*status text       */

   110     XFontSet fontset;           /*fontset for drawing    */

   111     int      off_x, off_y;

   112     Bool     on;                /*if the status window on*/

   113 } StatusWindow;

   114 #endif

   115 

   116 /*

   117  * X11InputMethodData keeps per X11InputMethod instance information. A pointer

   118  * to this data structure is kept in an X11InputMethod object (pData).

   119  */

   120 typedef struct _X11InputMethodData {

   121     XIC         current_ic;     /* current X Input Context */

   122     XIC         ic_active;      /* X Input Context for active clients */

   123     XIC         ic_passive;     /* X Input Context for passive clients */

   124     XIMCallback *callbacks;     /* callback parameters */

   125     jobject     x11inputmethod; /* global ref to X11InputMethod instance */

   126                                 /* associated with the XIC */

   127 #if defined(__linux__) || defined(MACOSX)

   128     StatusWindow *statusWindow; /* our own status window  */

   129 #endif

   130     char        *lookup_buf;    /* buffer used for XmbLookupString */

   131     int         lookup_buf_len; /* lookup buffer size in bytes */

   132 } X11InputMethodData;

   133 

   134 /*

   135  * When XIC is created, a global reference is created for

   136  * sun.awt.X11InputMethod object so that it could be used by the XIM callback

   137  * functions. This could be a dangerous thing to do when the original

   138  * X11InputMethod object is garbage collected and as a result,

   139  * destroyX11InputMethodData is called to delete the global reference.

   140  * If any XIM callback function still holds and uses the "already deleted"

   141  * global reference, disaster is going to happen. So we have to maintain

   142  * a list for these global references which is consulted first when the

   143  * callback functions or any function tries to use "currentX11InputMethodObject"

   144  * which always refers to the global reference try to use it.

   145  *

   146  */

   147 typedef struct _X11InputMethodGRefNode {

   148     jobject inputMethodGRef;

   149     struct _X11InputMethodGRefNode* next;

   150 } X11InputMethodGRefNode;

   151 

   152 X11InputMethodGRefNode *x11InputMethodGRefListHead = NULL;

   153 

   154 /* reference to the current X11InputMethod instance, it is always

   155    point to the global reference to the X11InputMethodObject since

   156    it could be referenced by different threads. */

   157 jobject currentX11InputMethodInstance = NULL;

   158 

   159 Window  currentFocusWindow = 0;  /* current window that has focus for input

   160                                        method. (the best place to put this

   161                                        information should be

   162                                        currentX11InputMethodInstance's pData) */

   163 static XIM X11im = NULL;

   164 Display * dpy = NULL;

   165 

   166 #define GetJNIEnv() (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2)

   167 

   168 static void DestroyXIMCallback(XIM, XPointer, XPointer);

   169 static void OpenXIMCallback(Display *, XPointer, XPointer);

   170 /* Solaris XIM Extention */

   171 #define XNCommitStringCallback "commitStringCallback"

   172 static void CommitStringCallback(XIC, XPointer, XPointer);

   173 

   174 static X11InputMethodData * getX11InputMethodData(JNIEnv *, jobject);

   175 static void setX11InputMethodData(JNIEnv *, jobject, X11InputMethodData *);

   176 static void destroyX11InputMethodData(JNIEnv *, X11InputMethodData *);

   177 static void freeX11InputMethodData(JNIEnv *, X11InputMethodData *);

   178 

   179 #ifdef __solaris__

   180 /* Prototype for this function is missing in Solaris X11R6 Xlib.h */

   181 extern char *XSetIMValues(

   182 #if NeedVarargsPrototypes

   183     XIM /* im */, ...

   184 #endif

   185 );

   186 #endif

   187 

   188 /*

   189  * This function is stolen from /src/solaris/hpi/src/system_md.c

   190  * It is used in setting the time in Java-level InputEvents

   191  */

   192 jlong

   193 awt_util_nowMillisUTC()

   194 {

   195     struct timeval t;

   196     gettimeofday(&t, NULL);

   197     return ((jlong)t.tv_sec) * 1000 + (jlong)(t.tv_usec/1000);

   198 }

   199 

   200 /*

   201  * Converts the wchar_t string to a multi-byte string calling wcstombs(). A

   202  * buffer is allocated by malloc() to store the multi-byte string. NULL is

   203  * returned if the given wchar_t string pointer is NULL or buffer allocation is

   204  * failed.

   205  */

   206 static char *

   207 wcstombsdmp(wchar_t *wcs, int len)

   208 {

   209     size_t n;

   210     char *mbs;

   211 

   212     if (wcs == NULL)

   213         return NULL;

   214 

   215     n = len*MB_CUR_MAX + 1;

   216 

   217     mbs = (char *) malloc(n * sizeof(char));

   218     if (mbs == NULL) {

   219         THROW_OUT_OF_MEMORY_ERROR();

   220         return NULL;

   221     }

   222 

   223     /* TODO: check return values... Handle invalid characters properly...  */

   224     if (wcstombs(mbs, wcs, n) == (size_t)-1) {

   225         free(mbs);

   226         return NULL;

   227     }

   228 

   229     return mbs;

   230 }

   231 

   232 /*

   233  * Returns True if the global reference is still in the list,

   234  * otherwise False.

   235  */

   236 static Bool isX11InputMethodGRefInList(jobject imGRef) {

   237     X11InputMethodGRefNode *pX11InputMethodGRef = x11InputMethodGRefListHead;

   238 

   239     if (imGRef == NULL) {

   240         return False;

   241     }

   242 

   243     while (pX11InputMethodGRef != NULL) {

   244         if (pX11InputMethodGRef->inputMethodGRef == imGRef) {

   245             return True;

   246         }

   247         pX11InputMethodGRef = pX11InputMethodGRef->next;

   248     }

   249 

   250     return False;

   251 }

   252 

   253 /*

   254  * Add the new created global reference to the list.

   255  */

   256 static void addToX11InputMethodGRefList(jobject newX11InputMethodGRef) {

   257     X11InputMethodGRefNode *newNode = NULL;

   258 

   259     if (newX11InputMethodGRef == NULL ||

   260         isX11InputMethodGRefInList(newX11InputMethodGRef)) {

   261         return;

   262     }

   263 

   264     newNode = (X11InputMethodGRefNode *)malloc(sizeof(X11InputMethodGRefNode));

   265 

   266     if (newNode == NULL) {

   267         return;

   268     } else {

   269         newNode->inputMethodGRef = newX11InputMethodGRef;

   270         newNode->next = x11InputMethodGRefListHead;

   271         x11InputMethodGRefListHead = newNode;

   272     }

   273 }

   274 

   275 /*

   276  * Remove the global reference from the list.

   277  */

   278 static void removeX11InputMethodGRefFromList(jobject x11InputMethodGRef) {

   279      X11InputMethodGRefNode *pX11InputMethodGRef = NULL;

   280      X11InputMethodGRefNode *cX11InputMethodGRef = x11InputMethodGRefListHead;

   281 

   282      if (x11InputMethodGRefListHead == NULL ||

   283          x11InputMethodGRef == NULL) {

   284          return;

   285      }

   286 

   287      /* cX11InputMethodGRef always refers to the current node while

   288         pX11InputMethodGRef refers to the previous node.

   289      */

   290      while (cX11InputMethodGRef != NULL) {

   291          if (cX11InputMethodGRef->inputMethodGRef == x11InputMethodGRef) {

   292              break;

   293          }

   294          pX11InputMethodGRef = cX11InputMethodGRef;

   295          cX11InputMethodGRef = cX11InputMethodGRef->next;

   296      }

   297 

   298      if (cX11InputMethodGRef == NULL) {

   299          return; /* Not found. */

   300      }

   301 

   302      if (cX11InputMethodGRef == x11InputMethodGRefListHead) {

   303          x11InputMethodGRefListHead = x11InputMethodGRefListHead->next;

   304      } else {

   305          pX11InputMethodGRef->next = cX11InputMethodGRef->next;

   306      }

   307      free(cX11InputMethodGRef);

   308 

   309      return;

   310 }

   311 

   312 

   313 static X11InputMethodData * getX11InputMethodData(JNIEnv * env, jobject imInstance) {

   314     X11InputMethodData *pX11IMData =

   315         (X11InputMethodData *)JNU_GetLongFieldAsPtr(env, imInstance, x11InputMethodIDs.pData);

   316 

   317     /*

   318      * In case the XIM server was killed somehow, reset X11InputMethodData.

   319      */

   320     if (X11im == NULL && pX11IMData != NULL) {

   321         JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,

   322                              "flushText",

   323                              "()V");

   324         JNU_CHECK_EXCEPTION_RETURN(env, NULL);

   325         /* IMPORTANT:

   326            The order of the following calls is critical since "imInstance" may

   327            point to the global reference itself, if "freeX11InputMethodData" is called

   328            first, the global reference will be destroyed and "setX11InputMethodData"

   329            will in fact fail silently. So pX11IMData will not be set to NULL.

   330            This could make the original java object refers to a deleted pX11IMData

   331            object.

   332         */

   333         setX11InputMethodData(env, imInstance, NULL);

   334         freeX11InputMethodData(env, pX11IMData);

   335         pX11IMData = NULL;

   336     }

   337 

   338     return pX11IMData;

   339 }

   340 

   341 static void setX11InputMethodData(JNIEnv * env, jobject imInstance, X11InputMethodData *pX11IMData) {

   342     JNU_SetLongFieldFromPtr(env, imInstance, x11InputMethodIDs.pData, pX11IMData);

   343 }

   344 

   345 /* this function should be called within AWT_LOCK() */

   346 static void

   347 destroyX11InputMethodData(JNIEnv *env, X11InputMethodData *pX11IMData)

   348 {

   349     /*

   350      * Destroy XICs

   351      */

   352     if (pX11IMData == NULL) {

   353         return;

   354     }

   355 

   356     if (pX11IMData->ic_active != (XIC)0) {

   357         XUnsetICFocus(pX11IMData->ic_active);

   358         XDestroyIC(pX11IMData->ic_active);

   359         if (pX11IMData->ic_active != pX11IMData->ic_passive) {

   360             if (pX11IMData->ic_passive != (XIC)0) {

   361                 XUnsetICFocus(pX11IMData->ic_passive);

   362                 XDestroyIC(pX11IMData->ic_passive);

   363             }

   364             pX11IMData->ic_passive = (XIC)0;

   365             pX11IMData->current_ic = (XIC)0;

   366         }

   367     }

   368 

   369     freeX11InputMethodData(env, pX11IMData);

   370 }

   371 

   372 static void

   373 freeX11InputMethodData(JNIEnv *env, X11InputMethodData *pX11IMData)

   374 {

   375 #if defined(__linux__) || defined(MACOSX)

   376     if (pX11IMData->statusWindow != NULL){

   377         StatusWindow *sw = pX11IMData->statusWindow;

   378         XFreeGC(awt_display, sw->lightGC);

   379         XFreeGC(awt_display, sw->dimGC);

   380         XFreeGC(awt_display, sw->bgGC);

   381         XFreeGC(awt_display, sw->fgGC);

   382         if (sw->fontset != NULL) {

   383             XFreeFontSet(awt_display, sw->fontset);

   384         }

   385         XDestroyWindow(awt_display, sw->w);

   386         free((void*)sw);

   387     }

   388 #endif

   389 

   390     if (pX11IMData->callbacks)

   391         free((void *)pX11IMData->callbacks);

   392 

   393     if (env) {

   394         /* Remove the global reference from the list, so that

   395            the callback function or whoever refers to it could know.

   396         */

   397         removeX11InputMethodGRefFromList(pX11IMData->x11inputmethod);

   398         (*env)->DeleteGlobalRef(env, pX11IMData->x11inputmethod);

   399     }

   400 

   401     if (pX11IMData->lookup_buf) {

   402         free((void *)pX11IMData->lookup_buf);

   403     }

   404 

   405     free((void *)pX11IMData);

   406 }

   407 

   408 /*

   409  * Sets or unsets the focus to the given XIC.

   410  */

   411 static void

   412 setXICFocus(XIC ic, unsigned short req)

   413 {

   414     if (ic == NULL) {

   415         (void)fprintf(stderr, "Couldn't find X Input Context\n");

   416         return;

   417     }

   418     if (req == 1)

   419         XSetICFocus(ic);

   420     else

   421         XUnsetICFocus(ic);

   422 }

   423 

   424 /*

   425  * Sets the focus window to the given XIC.

   426  */

   427 static void

   428 setXICWindowFocus(XIC ic, Window w)

   429 {

   430     if (ic == NULL) {

   431         (void)fprintf(stderr, "Couldn't find X Input Context\n");

   432         return;

   433     }

   434     (void) XSetICValues(ic, XNFocusWindow, w, NULL);

   435 }

   436 

   437 /*

   438  * Invokes XmbLookupString() to get something from the XIM. It invokes

   439  * X11InputMethod.dispatchCommittedText() if XmbLookupString() returns

   440  * committed text.  This function is called from handleKeyEvent in canvas.c and

   441  * it's under the Motif event loop thread context.

   442  *

   443  * Buffer usage: There is a bug in XFree86-4.3.0 XmbLookupString implementation,

   444  * where it never returns XBufferOverflow.  We need to allocate the initial lookup buffer

   445  * big enough, so that the possibility that user encounters this problem is relatively

   446  * small.  When this bug gets fixed, we can make the initial buffer size smaller.

   447  * Note that XmbLookupString() sometimes produces a non-null-terminated string.

   448  *

   449  * Returns True when there is a keysym value to be handled.

   450  */

   451 #define INITIAL_LOOKUP_BUF_SIZE 512

   452 

   453 Boolean

   454 awt_x11inputmethod_lookupString(XKeyPressedEvent *event, KeySym *keysymp)

   455 {

   456     JNIEnv *env = GetJNIEnv();

   457     X11InputMethodData *pX11IMData = NULL;

   458     KeySym keysym = NoSymbol;

   459     Status status;

   460     int mblen;

   461     jstring javastr;

   462     XIC ic;

   463     Boolean result = True;

   464     static Boolean composing = False;

   465 

   466     /*

   467       printf("lookupString: entering...\n");

   468      */

   469 

   470     if (!isX11InputMethodGRefInList(currentX11InputMethodInstance)) {

   471         currentX11InputMethodInstance = NULL;

   472         return False;

   473     }

   474 

   475     pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance);

   476 

   477     if (pX11IMData == NULL) {

   478 #if defined(__linux__) || defined(MACOSX)

   479         return False;

   480 #else

   481         return result;

   482 #endif

   483     }

   484 

   485     if ((ic = pX11IMData->current_ic) == (XIC)0){

   486 #if defined(__linux__) || defined(MACOSX)

   487         return False;

   488 #else

   489         return result;

   490 #endif

   491     }

   492 

   493     /* allocate the lookup buffer at the first invocation */

   494     if (pX11IMData->lookup_buf_len == 0) {

   495         pX11IMData->lookup_buf = (char *)malloc(INITIAL_LOOKUP_BUF_SIZE);

   496         if (pX11IMData->lookup_buf == NULL) {

   497             THROW_OUT_OF_MEMORY_ERROR();

   498             return result;

   499         }

   500         pX11IMData->lookup_buf_len = INITIAL_LOOKUP_BUF_SIZE;

   501     }

   502 

   503     mblen = XmbLookupString(ic, event, pX11IMData->lookup_buf,

   504                             pX11IMData->lookup_buf_len - 1, &keysym, &status);

   505 

   506     /*

   507      * In case of overflow, a buffer is allocated and it retries

   508      * XmbLookupString().

   509      */

   510     if (status == XBufferOverflow) {

   511         free((void *)pX11IMData->lookup_buf);

   512         pX11IMData->lookup_buf_len = 0;

   513         pX11IMData->lookup_buf = (char *)malloc(mblen + 1);

   514         if (pX11IMData->lookup_buf == NULL) {

   515             THROW_OUT_OF_MEMORY_ERROR();

   516             return result;

   517         }

   518         pX11IMData->lookup_buf_len = mblen + 1;

   519         mblen = XmbLookupString(ic, event, pX11IMData->lookup_buf,

   520                             pX11IMData->lookup_buf_len - 1, &keysym, &status);

   521     }

   522     pX11IMData->lookup_buf[mblen] = 0;

   523 

   524     /* Get keysym without taking modifiers into account first to map

   525      * to AWT keyCode table.

   526      */

   527     switch (status) {

   528     case XLookupBoth:

   529         if (!composing) {

   530             if (event->keycode != 0) {

   531                 *keysymp = keysym;

   532                 result = False;

   533                 break;

   534             }

   535         }

   536         composing = False;

   537         /*FALLTHRU*/

   538     case XLookupChars:

   539     /*

   540      printf("lookupString: status=XLookupChars, type=%d, state=%x, keycode=%x, keysym=%x\n",

   541        event->type, event->state, event->keycode, keysym);

   542     */

   543         javastr = JNU_NewStringPlatform(env, (const char *)pX11IMData->lookup_buf);

   544         if (javastr != NULL) {

   545             JNU_CallMethodByName(env, NULL,

   546                                  currentX11InputMethodInstance,

   547                                  "dispatchCommittedText",

   548                                  "(Ljava/lang/String;J)V",

   549                                  javastr,

   550                                  event->time);

   551         }

   552         break;

   553 

   554     case XLookupKeySym:

   555     /*

   556      printf("lookupString: status=XLookupKeySym, type=%d, state=%x, keycode=%x, keysym=%x\n",

   557        event->type, event->state, event->keycode, keysym);

   558     */

   559         if (keysym == XK_Multi_key)

   560             composing = True;

   561         if (! composing) {

   562             *keysymp = keysym;

   563             result = False;

   564         }

   565         break;

   566 

   567     case XLookupNone:

   568     /*

   569      printf("lookupString: status=XLookupNone, type=%d, state=%x, keycode=%x, keysym=%x\n",

   570         event->type, event->state, event->keycode, keysym);

   571     */

   572         break;

   573     }

   574 

   575     return result;

   576 }

   577 

   578 #if defined(__linux__) || defined(MACOSX)

   579 static StatusWindow *createStatusWindow(

   580                                 Window parent) {

   581     StatusWindow *statusWindow;

   582     XSetWindowAttributes attrib;

   583     unsigned long attribmask;

   584     Window containerWindow;

   585     Window status;

   586     Window child;

   587     XWindowAttributes xwa;

   588     XWindowAttributes xxwa;

   589     /* Variable for XCreateFontSet()*/

   590     char **mclr;

   591     int  mccr = 0;

   592     char *dsr;

   593     unsigned long bg, fg, light, dim;

   594     int x, y, off_x, off_y, xx, yy;

   595     unsigned int w, h, bw, depth;

   596     XGCValues values;

   597     unsigned long valuemask = 0;  /*ignore XGCvalue and use defaults*/

   598     int screen = 0;

   599     int i;

   600     AwtGraphicsConfigDataPtr adata;

   601     extern int awt_numScreens;

   602     /*hardcode the size right now, should get the size base on font*/

   603     int   width=80, height=22;

   604     Window rootWindow;

   605     Window *ignoreWindowPtr;

   606     unsigned int ignoreUnit;

   607 

   608     XGetGeometry(dpy, parent, &rootWindow, &x, &y, &w, &h, &bw, &depth);

   609 

   610     attrib.override_redirect = True;

   611     attribmask = CWOverrideRedirect;

   612     for (i = 0; i < awt_numScreens; i++) {

   613         if (RootWindow(dpy, i) == rootWindow) {

   614             screen = i;

   615             break;

   616         }

   617     }

   618     adata = getDefaultConfig(screen);

   619     bg    = adata->AwtColorMatch(255, 255, 255, adata);

   620     fg    = adata->AwtColorMatch(0, 0, 0, adata);

   621     light = adata->AwtColorMatch(195, 195, 195, adata);

   622     dim   = adata->AwtColorMatch(128, 128, 128, adata);

   623 

   624     XGetWindowAttributes(dpy, parent, &xwa);

   625     bw = 2; /*xwa.border_width does not have the correct value*/

   626 

   627     /*compare the size difference between parent container

   628       and shell widget, the diff should be the border frame

   629       and title bar height (?)*/

   630 

   631     XQueryTree( dpy,

   632                 parent,

   633                 &rootWindow,

   634                 &containerWindow,

   635                 &ignoreWindowPtr,

   636                 &ignoreUnit);

   637     XGetWindowAttributes(dpy, containerWindow, &xxwa);

   638 

   639     off_x = (xxwa.width - xwa.width) / 2;

   640     off_y = xxwa.height - xwa.height - off_x; /*it's magic:-) */

   641 

   642     /*get the size of root window*/

   643     XGetWindowAttributes(dpy, rootWindow, &xxwa);

   644 

   645     XTranslateCoordinates(dpy,

   646                           parent, xwa.root,

   647                           xwa.x, xwa.y,

   648                           &x, &y,

   649                           &child);

   650     xx = x - off_x;

   651     yy = y + xwa.height - off_y;

   652     if (xx < 0 ){

   653         xx = 0;

   654     }

   655     if (xx + width > xxwa.width){

   656         xx = xxwa.width - width;

   657     }

   658     if (yy + height > xxwa.height){

   659         yy = xxwa.height - height;

   660     }

   661 

   662     status =  XCreateWindow(dpy,

   663                             xwa.root,

   664                             xx, yy,

   665                             width, height,

   666                             0,

   667                             xwa.depth,

   668                             InputOutput,

   669                             adata->awt_visInfo.visual,

   670                             attribmask, &attrib);

   671     XSelectInput(dpy, status,

   672                  ExposureMask | StructureNotifyMask | EnterWindowMask |

   673                  LeaveWindowMask | VisibilityChangeMask);

   674     statusWindow = (StatusWindow*) calloc(1, sizeof(StatusWindow));

   675     if (statusWindow == NULL){

   676         THROW_OUT_OF_MEMORY_ERROR();

   677         return NULL;

   678     }

   679     statusWindow->w = status;

   680     //12-point font

   681     statusWindow->fontset = XCreateFontSet(dpy,

   682                                            "-*-*-medium-r-normal-*-*-120-*-*-*-*",

   683                                            &mclr, &mccr, &dsr);

   684     /* In case we didn't find the font set, release the list of missing characters */

   685     if (mccr > 0) {

   686         XFreeStringList(mclr);

   687     }

   688     statusWindow->parent = parent;

   689     statusWindow->on  = False;

   690     statusWindow->x = x;

   691     statusWindow->y = y;

   692     statusWindow->width = xwa.width;

   693     statusWindow->height = xwa.height;

   694     statusWindow->off_x = off_x;

   695     statusWindow->off_y = off_y;

   696     statusWindow->bWidth  = bw;

   697     statusWindow->statusH = height;

   698     statusWindow->statusW = width;

   699     statusWindow->rootH = xxwa.height;

   700     statusWindow->rootW = xxwa.width;

   701     statusWindow->lightGC = XCreateGC(dpy, status, valuemask, &values);

   702     XSetForeground(dpy, statusWindow->lightGC, light);

   703     statusWindow->dimGC = XCreateGC(dpy, status, valuemask, &values);

   704     XSetForeground(dpy, statusWindow->dimGC, dim);

   705     statusWindow->fgGC = XCreateGC(dpy, status, valuemask, &values);

   706     XSetForeground(dpy, statusWindow->fgGC, fg);

   707     statusWindow->bgGC = XCreateGC(dpy, status, valuemask, &values);

   708     XSetForeground(dpy, statusWindow->bgGC, bg);

   709     return statusWindow;

   710 }

   711 

   712 /* This method is to turn off or turn on the status window. */

   713 static void onoffStatusWindow(X11InputMethodData* pX11IMData,

   714                                 Window parent,

   715                                 Bool ON){

   716     XWindowAttributes xwa;

   717     Window child;

   718     int x, y;

   719     StatusWindow *statusWindow = NULL;

   720 

   721     if (NULL == currentX11InputMethodInstance ||

   722         NULL == pX11IMData ||

   723         NULL == (statusWindow =  pX11IMData->statusWindow)){

   724         return;

   725     }

   726 

   727     if (ON == False){

   728         XUnmapWindow(dpy, statusWindow->w);

   729         statusWindow->on = False;

   730         return;

   731     }

   732     parent = JNU_CallMethodByName(GetJNIEnv(), NULL, pX11IMData->x11inputmethod,

   733                                   "getCurrentParentWindow",

   734                                   "()J").j;

   735     if (statusWindow->parent != parent){

   736         statusWindow->parent = parent;

   737     }

   738     XGetWindowAttributes(dpy, parent, &xwa);

   739     XTranslateCoordinates(dpy,

   740                           parent, xwa.root,

   741                           xwa.x, xwa.y,

   742                           &x, &y,

   743                           &child);

   744     if (statusWindow->x != x

   745         || statusWindow->y != y

   746         || statusWindow->height != xwa.height){

   747         statusWindow->x = x;

   748         statusWindow->y = y;

   749         statusWindow->height = xwa.height;

   750         x = statusWindow->x - statusWindow->off_x;

   751         y = statusWindow->y + statusWindow->height - statusWindow->off_y;

   752         if (x < 0 ){

   753             x = 0;

   754         }

   755         if (x + statusWindow->statusW > statusWindow->rootW){

   756             x = statusWindow->rootW - statusWindow->statusW;

   757         }

   758         if (y + statusWindow->statusH > statusWindow->rootH){

   759             y = statusWindow->rootH - statusWindow->statusH;

   760         }

   761         XMoveWindow(dpy, statusWindow->w, x, y);

   762     }

   763     statusWindow->on = True;

   764     XMapWindow(dpy, statusWindow->w);

   765 }

   766 

   767 void paintStatusWindow(StatusWindow *statusWindow){

   768     Window  win  = statusWindow->w;

   769     GC  lightgc = statusWindow->lightGC;

   770     GC  dimgc = statusWindow->dimGC;

   771     GC  bggc = statusWindow->bgGC;

   772     GC  fggc = statusWindow->fgGC;

   773 

   774     int width = statusWindow->statusW;

   775     int height = statusWindow->statusH;

   776     int bwidth = statusWindow->bWidth;

   777     XFillRectangle(dpy, win, bggc, 0, 0, width, height);

   778     /* draw border */

   779     XDrawLine(dpy, win, fggc, 0, 0, width, 0);

   780     XDrawLine(dpy, win, fggc, 0, height-1, width-1, height-1);

   781     XDrawLine(dpy, win, fggc, 0, 0, 0, height-1);

   782     XDrawLine(dpy, win, fggc, width-1, 0, width-1, height-1);

   783 

   784     XDrawLine(dpy, win, lightgc, 1, 1, width-bwidth, 1);

   785     XDrawLine(dpy, win, lightgc, 1, 1, 1, height-2);

   786     XDrawLine(dpy, win, lightgc, 1, height-2, width-bwidth, height-2);

   787     XDrawLine(dpy, win, lightgc, width-bwidth-1, 1, width-bwidth-1, height-2);

   788 

   789     XDrawLine(dpy, win, dimgc, 2, 2, 2, height-3);

   790     XDrawLine(dpy, win, dimgc, 2, height-3, width-bwidth-1, height-3);

   791     XDrawLine(dpy, win, dimgc, 2, 2, width-bwidth-2, 2);

   792     XDrawLine(dpy, win, dimgc, width-bwidth, 2, width-bwidth, height-3);

   793     if (statusWindow->fontset){

   794         XmbDrawString(dpy, win, statusWindow->fontset, fggc,

   795                       bwidth + 2, height - bwidth - 4,

   796                       statusWindow->status,

   797                       strlen(statusWindow->status));

   798     }

   799     else{

   800         /*too bad we failed to create a fontset for this locale*/

   801         XDrawString(dpy, win, fggc, bwidth + 2, height - bwidth - 4,

   802                     "[InputMethod ON]", strlen("[InputMethod ON]"));

   803     }

   804 }

   805 

   806 void statusWindowEventHandler(XEvent event){

   807     JNIEnv *env = GetJNIEnv();

   808     X11InputMethodData *pX11IMData = NULL;

   809     StatusWindow *statusWindow;

   810 

   811     if (!isX11InputMethodGRefInList(currentX11InputMethodInstance)) {

   812         currentX11InputMethodInstance = NULL;

   813         return;

   814     }

   815 

   816     if (NULL == currentX11InputMethodInstance

   817         || NULL == (pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance))

   818         || NULL == (statusWindow = pX11IMData->statusWindow)

   819         || statusWindow->w != event.xany.window){

   820         return;

   821     }

   822 

   823     switch (event.type){

   824     case Expose:

   825         paintStatusWindow(statusWindow);

   826         break;

   827     case MapNotify:

   828     case ConfigureNotify:

   829         {

   830           /*need to reset the stackMode...*/

   831             XWindowChanges xwc;

   832             int value_make = CWStackMode;

   833             xwc.stack_mode = TopIf;

   834             XConfigureWindow(dpy, statusWindow->w, value_make, &xwc);

   835         }

   836         break;

   837         /*

   838     case UnmapNotify:

   839     case VisibilityNotify:

   840         break;

   841         */

   842     default:

   843         break;

   844   }

   845 }

   846 

   847 static void adjustStatusWindow(Window shell){

   848     JNIEnv *env = GetJNIEnv();

   849     X11InputMethodData *pX11IMData = NULL;

   850     StatusWindow *statusWindow;

   851 

   852     if (NULL == currentX11InputMethodInstance

   853         || !isX11InputMethodGRefInList(currentX11InputMethodInstance)

   854         || NULL == (pX11IMData = getX11InputMethodData(env,currentX11InputMethodInstance))

   855         || NULL == (statusWindow = pX11IMData->statusWindow)

   856         || !statusWindow->on) {

   857         return;

   858     }

   859     {

   860         XWindowAttributes xwa;

   861         int x, y;

   862         Window child;

   863         XGetWindowAttributes(dpy, shell, &xwa);

   864         XTranslateCoordinates(dpy,

   865                               shell, xwa.root,

   866                               xwa.x, xwa.y,

   867                               &x, &y,

   868                               &child);

   869         if (statusWindow->x != x

   870             || statusWindow->y != y

   871             || statusWindow->height != xwa.height){

   872           statusWindow->x = x;

   873           statusWindow->y = y;

   874           statusWindow->height = xwa.height;

   875 

   876           x = statusWindow->x - statusWindow->off_x;

   877           y = statusWindow->y + statusWindow->height - statusWindow->off_y;

   878           if (x < 0 ){

   879               x = 0;

   880           }

   881           if (x + statusWindow->statusW > statusWindow->rootW){

   882               x = statusWindow->rootW - statusWindow->statusW;

   883           }

   884           if (y + statusWindow->statusH > statusWindow->rootH){

   885               y = statusWindow->rootH - statusWindow->statusH;

   886           }

   887           XMoveWindow(dpy, statusWindow->w, x, y);

   888         }

   889     }

   890 }

   891 #endif  /* __linux__ || MACOSX */

   892 /*

   893  * Creates two XICs, one for active clients and the other for passive

   894  * clients. All information on those XICs are stored in the

   895  * X11InputMethodData given by the pX11IMData parameter.

   896  *

   897  * For active clients: Try to use preedit callback to support

   898  * on-the-spot. If tc is not null, the XIC to be created will

   899  * share the Status Area with Motif widgets (TextComponents). If the

   900  * preferable styles can't be used, fallback to root-window styles. If

   901  * root-window styles failed, fallback to None styles.

   902  *

   903  * For passive clients: Try to use root-window styles. If failed,

   904  * fallback to None styles.

   905  */

   906 static Bool

   907 createXIC(JNIEnv * env, X11InputMethodData *pX11IMData, Window w)

   908 {

   909     XVaNestedList preedit = NULL;

   910     XVaNestedList status = NULL;

   911     XIMStyle on_the_spot_styles = XIMPreeditCallbacks,

   912              active_styles = 0,

   913              passive_styles = 0,

   914              no_styles = 0;

   915     XIMCallback *callbacks;

   916     unsigned short i;

   917     XIMStyles *im_styles;

   918     char *ret = NULL;

   919 

   920     if (X11im == NULL) {

   921         return False;

   922     }

   923     if (!w) {

   924         return False;

   925     }

   926 

   927     ret = XGetIMValues(X11im, XNQueryInputStyle, &im_styles, NULL);

   928 

   929     if (ret != NULL) {

   930         jio_fprintf(stderr,"XGetIMValues: %s\n",ret);

   931         return FALSE ;

   932     }

   933 

   934 #if defined(__linux__) || defined(MACOSX)

   935     on_the_spot_styles |= XIMStatusNothing;

   936 

   937     /*kinput does not support XIMPreeditCallbacks and XIMStatusArea

   938       at the same time, so use StatusCallback to draw the status

   939       ourself

   940     */

   941     for (i = 0; i < im_styles->count_styles; i++) {

   942         if (im_styles->supported_styles[i] == (XIMPreeditCallbacks | XIMStatusCallbacks)) {

   943             on_the_spot_styles = (XIMPreeditCallbacks | XIMStatusCallbacks);

   944             break;

   945         }

   946     }

   947 #else /*! __linux__ && !MACOSX */

   948     on_the_spot_styles |= XIMStatusNothing;

   949 #endif /* __linux__ || MACOSX */

   950 

   951     for (i = 0; i < im_styles->count_styles; i++) {

   952         active_styles |= im_styles->supported_styles[i] & on_the_spot_styles;

   953         passive_styles |= im_styles->supported_styles[i] & ROOT_WINDOW_STYLES;

   954         no_styles |= im_styles->supported_styles[i] & NO_STYLES;

   955     }

   956 

   957     XFree(im_styles);

   958 

   959     if (active_styles != on_the_spot_styles) {

   960         if (passive_styles == ROOT_WINDOW_STYLES)

   961             active_styles = passive_styles;

   962         else {

   963             if (no_styles == NO_STYLES)

   964                 active_styles = passive_styles = NO_STYLES;

   965             else

   966                 active_styles = passive_styles = 0;

   967         }

   968     } else {

   969         if (passive_styles != ROOT_WINDOW_STYLES) {

   970             if (no_styles == NO_STYLES)

   971                 active_styles = passive_styles = NO_STYLES;

   972             else

   973                 active_styles = passive_styles = 0;

   974         }

   975     }

   976 

   977     if (active_styles == on_the_spot_styles) {

   978         pX11IMData->ic_passive = XCreateIC(X11im,

   979                                    XNClientWindow, w,

   980                                    XNFocusWindow, w,

   981                                    XNInputStyle, passive_styles,

   982                                    NULL);

   983 

   984         callbacks = (XIMCallback *)malloc(sizeof(XIMCallback) * NCALLBACKS);

   985         if (callbacks == (XIMCallback *)NULL)

   986             return False;

   987         pX11IMData->callbacks = callbacks;

   988 

   989         for (i = 0; i < NCALLBACKS; i++, callbacks++) {

   990             callbacks->client_data = (XPointer) pX11IMData->x11inputmethod;

   991             callbacks->callback = callback_funcs[i];

   992         }

   993 

   994         callbacks = pX11IMData->callbacks;

   995         preedit = (XVaNestedList)XVaCreateNestedList(0,

   996                         XNPreeditStartCallback, &callbacks[PreeditStartIndex],

   997                         XNPreeditDoneCallback,  &callbacks[PreeditDoneIndex],

   998                         XNPreeditDrawCallback,  &callbacks[PreeditDrawIndex],

   999                         XNPreeditCaretCallback, &callbacks[PreeditCaretIndex],

  1000                         NULL);

  1001         if (preedit == (XVaNestedList)NULL)

  1002             goto err;

  1003 #if defined(__linux__) || defined(MACOSX)

  1004         /*always try XIMStatusCallbacks for active client...*/

  1005         {

  1006             status = (XVaNestedList)XVaCreateNestedList(0,

  1007                         XNStatusStartCallback, &callbacks[StatusStartIndex],

  1008                         XNStatusDoneCallback,  &callbacks[StatusDoneIndex],

  1009                         XNStatusDrawCallback, &callbacks[StatusDrawIndex],

  1010                         NULL);

  1011 

  1012             if (status == NULL)

  1013                 goto err;

  1014             pX11IMData->statusWindow = createStatusWindow(w);

  1015             pX11IMData->ic_active = XCreateIC(X11im,

  1016                                               XNClientWindow, w,

  1017                                               XNFocusWindow, w,

  1018                                               XNInputStyle, active_styles,

  1019                                               XNPreeditAttributes, preedit,

  1020                                               XNStatusAttributes, status,

  1021                                               NULL);

  1022             XFree((void *)status);

  1023             XFree((void *)preedit);

  1024         }

  1025 #else /* !__linux__ && !MACOSX */

  1026             pX11IMData->ic_active = XCreateIC(X11im,

  1027                                               XNClientWindow, w,

  1028                                               XNFocusWindow, w,

  1029                                               XNInputStyle, active_styles,

  1030                                               XNPreeditAttributes, preedit,

  1031                                               NULL);

  1032         XFree((void *)preedit);

  1033 #endif /* __linux__ || MACOSX */

  1034     } else {

  1035         pX11IMData->ic_active = XCreateIC(X11im,

  1036                                           XNClientWindow, w,

  1037                                           XNFocusWindow, w,

  1038                                           XNInputStyle, active_styles,

  1039                                           NULL);

  1040         pX11IMData->ic_passive = pX11IMData->ic_active;

  1041     }

  1042 

  1043     if (pX11IMData->ic_active == (XIC)0

  1044         || pX11IMData->ic_passive == (XIC)0) {

  1045         return False;

  1046     }

  1047 

  1048     /*

  1049      * Use commit string call back if possible.

  1050      * This will ensure the correct order of preedit text and commit text

  1051      */

  1052     {

  1053         XIMCallback cb;

  1054         cb.client_data = (XPointer) pX11IMData->x11inputmethod;

  1055         cb.callback = (XIMProc) CommitStringCallback;

  1056         XSetICValues (pX11IMData->ic_active, XNCommitStringCallback, &cb, NULL);

  1057         if (pX11IMData->ic_active != pX11IMData->ic_passive) {

  1058             XSetICValues (pX11IMData->ic_passive, XNCommitStringCallback, &cb, NULL);

  1059         }

  1060     }

  1061 

  1062     /* Add the global reference object to X11InputMethod to the list. */

  1063     addToX11InputMethodGRefList(pX11IMData->x11inputmethod);

  1064 

  1065     return True;

  1066 

  1067  err:

  1068     if (preedit)

  1069         XFree((void *)preedit);

  1070     THROW_OUT_OF_MEMORY_ERROR();

  1071     return False;

  1072 }

  1073 

  1074 static void

  1075 PreeditStartCallback(XIC ic, XPointer client_data, XPointer call_data)

  1076 {

  1077     /*ARGSUSED*/

  1078     /* printf("Native: PreeditCaretCallback\n"); */

  1079 }

  1080 

  1081 static void

  1082 PreeditDoneCallback(XIC ic, XPointer client_data, XPointer call_data)

  1083 {

  1084     /*ARGSUSED*/

  1085     /* printf("Native: StatusStartCallback\n"); */

  1086 }

  1087 

  1088 /*

  1089  * Translate the preedit draw callback items to Java values and invoke

  1090  * X11InputMethod.dispatchComposedText().

  1091  *

  1092  * client_data: X11InputMethod object

  1093  */

  1094 static void

  1095 PreeditDrawCallback(XIC ic, XPointer client_data,

  1096                     XIMPreeditDrawCallbackStruct *pre_draw)

  1097 {

  1098     JNIEnv *env = GetJNIEnv();

  1099     X11InputMethodData *pX11IMData = NULL;

  1100     jmethodID x11imMethodID;

  1101 

  1102     XIMText *text;

  1103     jstring javastr = NULL;

  1104     jintArray style = NULL;

  1105 

  1106     /* printf("Native: PreeditDrawCallback() \n"); */

  1107     if (pre_draw == NULL) {

  1108         return;

  1109     }

  1110     AWT_LOCK();

  1111     if (!isX11InputMethodGRefInList((jobject)client_data)) {

  1112         if ((jobject)client_data == currentX11InputMethodInstance) {

  1113             currentX11InputMethodInstance = NULL;

  1114         }

  1115         goto finally;

  1116     }

  1117     if ((pX11IMData = getX11InputMethodData(env, (jobject)client_data)) == NULL) {

  1118         goto finally;

  1119     }

  1120 

  1121     if ((text = pre_draw->text) != NULL) {

  1122         if (text->string.multi_byte != NULL) {

  1123             if (pre_draw->text->encoding_is_wchar == False) {

  1124                 javastr = JNU_NewStringPlatform(env, (const char *)text->string.multi_byte);

  1125                 if (javastr == NULL) {

  1126                     goto finally;

  1127                 }

  1128             } else {

  1129                 char *mbstr = wcstombsdmp(text->string.wide_char, text->length);

  1130                 if (mbstr == NULL) {

  1131                     goto finally;

  1132                 }

  1133                 javastr = JNU_NewStringPlatform(env, (const char *)mbstr);

  1134                 free(mbstr);