/*

 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

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

 * questions.

 */

#ifdef HEADLESS

    #error This file should not be included in headless library

#endif

#include <stdio.h>

#include <stdlib.h>

#include <X11/Xlib.h>

#include <X11/keysym.h>

#include <sys/time.h>

#include "awt.h"

#include "awt_p.h"

#include <sun_awt_X11InputMethod.h>

#include <sun_awt_X11_XInputMethod.h>

#define THROW_OUT_OF_MEMORY_ERROR() \

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

struct X11InputMethodIDs {

  jfieldID pData;

} x11InputMethodIDs;

static void PreeditStartCallback(XIC, XPointer, XPointer);

static void PreeditDoneCallback(XIC, XPointer, XPointer);

static void PreeditDrawCallback(XIC, XPointer,

                                XIMPreeditDrawCallbackStruct *);

static void PreeditCaretCallback(XIC, XPointer,

                                 XIMPreeditCaretCallbackStruct *);

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

static void StatusStartCallback(XIC, XPointer, XPointer);

static void StatusDoneCallback(XIC, XPointer, XPointer);

static void StatusDrawCallback(XIC, XPointer,

                               XIMStatusDrawCallbackStruct *);

#endif

#define ROOT_WINDOW_STYLES      (XIMPreeditNothing | XIMStatusNothing)

#define NO_STYLES               (XIMPreeditNone | XIMStatusNone)

#define PreeditStartIndex       0

#define PreeditDoneIndex        1

#define PreeditDrawIndex        2

#define PreeditCaretIndex       3

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

#define StatusStartIndex        4

#define StatusDoneIndex         5

#define StatusDrawIndex         6

#define NCALLBACKS              7

#else

#define NCALLBACKS              4

#endif

/*

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

 * values above.

 */

static XIMProc callback_funcs[NCALLBACKS] = {

    (XIMProc)PreeditStartCallback,

    (XIMProc)PreeditDoneCallback,

    (XIMProc)PreeditDrawCallback,

    (XIMProc)PreeditCaretCallback,

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

    (XIMProc)StatusStartCallback,

    (XIMProc)StatusDoneCallback,

    (XIMProc)StatusDrawCallback,

#endif

};

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

#define MAX_STATUS_LEN  100

typedef struct {

    Window   w;                /*status window id        */

    Window   root;             /*the root window id      */

    Window   parent;           /*parent shell window     */

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

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

    GC       lightGC;          /*gc for light border     */

    GC       dimGC;            /*gc for dim border       */

    GC       bgGC;             /*normal painting         */

    GC       fgGC;             /*normal painting         */

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

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

    int      bWidth;           /*border width            */

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

    XFontSet fontset;           /*fontset for drawing    */

    int      off_x, off_y;

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

} StatusWindow;

#endif

/*

 * X11InputMethodData keeps per X11InputMethod instance information. A pointer

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

 */

typedef struct _X11InputMethodData {

    XIC         current_ic;     /* current X Input Context */

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

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

    XIMCallback *callbacks;     /* callback parameters */

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

                                /* associated with the XIC */

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

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

#endif

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

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

} X11InputMethodData;

/*

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

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

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

 * X11InputMethod object is garbage collected and as a result,

 * destroyX11InputMethodData is called to delete the global reference.

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

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

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

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

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

 *

 */

typedef struct _X11InputMethodGRefNode {

    jobject inputMethodGRef;

    struct _X11InputMethodGRefNode* next;

} X11InputMethodGRefNode;

X11InputMethodGRefNode *x11InputMethodGRefListHead = NULL;

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

   point to the global reference to the X11InputMethodObject since

   it could be referenced by different threads. */

jobject currentX11InputMethodInstance = NULL;

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

                                       method. (the best place to put this

                                       information should be

                                       currentX11InputMethodInstance's pData) */

static XIM X11im = NULL;

Display * dpy = NULL;

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

static void DestroyXIMCallback(XIM, XPointer, XPointer);

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

/* Solaris XIM Extention */

#define XNCommitStringCallback "commitStringCallback"

static void CommitStringCallback(XIC, XPointer, XPointer);

static X11InputMethodData * getX11InputMethodData(JNIEnv *, jobject);

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

static void destroyX11InputMethodData(JNIEnv *, X11InputMethodData *);

static void freeX11InputMethodData(JNIEnv *, X11InputMethodData *);

#ifdef __solaris__

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

extern char *XSetIMValues(

#if NeedVarargsPrototypes

    XIM /* im */, ...

#endif

);

#endif

/*

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

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

 */

jlong

{

    struct timeval t;

    gettimeofday(&t, NULL);

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

}

/*

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

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

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

 * failed.

 */

static char *

wcstombsdmp(wchar_t *wcs, int len)

{

    size_t n;

    char *mbs;

    if (wcs == NULL)

        return NULL;

    n = len*MB_CUR_MAX + 1;

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

    if (mbs == NULL) {

        THROW_OUT_OF_MEMORY_ERROR();

        return NULL;

    }

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

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

        free(mbs);

        return NULL;

    }

    return mbs;

}

/*

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

 * otherwise False.

 */

static Bool isX11InputMethodGRefInList(jobject imGRef) {

    X11InputMethodGRefNode *pX11InputMethodGRef = x11InputMethodGRefListHead;

    if (imGRef == NULL) {

        return False;

    }

    while (pX11InputMethodGRef != NULL) {

        if (pX11InputMethodGRef->inputMethodGRef == imGRef) {

            return True;

        }

        pX11InputMethodGRef = pX11InputMethodGRef->next;

    }

    return False;

}

/*

 * Add the new created global reference to the list.

 */

static void addToX11InputMethodGRefList(jobject newX11InputMethodGRef) {

    X11InputMethodGRefNode *newNode = NULL;

    if (newX11InputMethodGRef == NULL ||

        isX11InputMethodGRefInList(newX11InputMethodGRef)) {

        return;

    }

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

    if (newNode == NULL) {

        return;

    } else {

        newNode->inputMethodGRef = newX11InputMethodGRef;

        newNode->next = x11InputMethodGRefListHead;

        x11InputMethodGRefListHead = newNode;

    }

}

/*

 * Remove the global reference from the list.

 */

static void removeX11InputMethodGRefFromList(jobject x11InputMethodGRef) {

     X11InputMethodGRefNode *pX11InputMethodGRef = NULL;

     X11InputMethodGRefNode *cX11InputMethodGRef = x11InputMethodGRefListHead;

     if (x11InputMethodGRefListHead == NULL ||

         x11InputMethodGRef == NULL) {

         return;

     }

     /* cX11InputMethodGRef always refers to the current node while

        pX11InputMethodGRef refers to the previous node.

     */

     while (cX11InputMethodGRef != NULL) {

         if (cX11InputMethodGRef->inputMethodGRef == x11InputMethodGRef) {

             break;

         }

         pX11InputMethodGRef = cX11InputMethodGRef;

         cX11InputMethodGRef = cX11InputMethodGRef->next;

     }

     if (cX11InputMethodGRef == NULL) {

         return; /* Not found. */

     }

     if (cX11InputMethodGRef == x11InputMethodGRefListHead) {

         x11InputMethodGRefListHead = x11InputMethodGRefListHead->next;

     } else {

         pX11InputMethodGRef->next = cX11InputMethodGRef->next;

     }

     free(cX11InputMethodGRef);

     return;

}

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

    X11InputMethodData *pX11IMData =

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

    /*

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

     */

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

        JNU_CallMethodByName(env, NULL, pX11IMData->x11inputmethod,

                             "flushText",

                             "()V");

        JNU_CHECK_EXCEPTION_RETURN(env, NULL);

        /* IMPORTANT:

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

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

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

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

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

           object.

        */

        setX11InputMethodData(env, imInstance, NULL);

        freeX11InputMethodData(env, pX11IMData);

        pX11IMData = NULL;

    }

    return pX11IMData;

}

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

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

}

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

static void

destroyX11InputMethodData(JNIEnv *env, X11InputMethodData *pX11IMData)

{

    /*

     * Destroy XICs

     */

    if (pX11IMData == NULL) {

        return;

    }

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

        XUnsetICFocus(pX11IMData->ic_active);

        XDestroyIC(pX11IMData->ic_active);

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

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

                XUnsetICFocus(pX11IMData->ic_passive);

                XDestroyIC(pX11IMData->ic_passive);

            }

            pX11IMData->ic_passive = (XIC)0;

            pX11IMData->current_ic = (XIC)0;

        }

    }

    freeX11InputMethodData(env, pX11IMData);

}

static void

freeX11InputMethodData(JNIEnv *env, X11InputMethodData *pX11IMData)

{

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

    if (pX11IMData->statusWindow != NULL){

        StatusWindow *sw = pX11IMData->statusWindow;

        XFreeGC(awt_display, sw->lightGC);

        XFreeGC(awt_display, sw->dimGC);

        XFreeGC(awt_display, sw->bgGC);

        XFreeGC(awt_display, sw->fgGC);

        if (sw->fontset != NULL) {

            XFreeFontSet(awt_display, sw->fontset);

        }

        XDestroyWindow(awt_display, sw->w);

        free((void*)sw);

    }

#endif

    if (pX11IMData->callbacks)

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

    if (env) {

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

           the callback function or whoever refers to it could know.

        */

        removeX11InputMethodGRefFromList(pX11IMData->x11inputmethod);

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

    }

    if (pX11IMData->lookup_buf) {

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

    }

    free((void *)pX11IMData);

}

/*

 * Sets or unsets the focus to the given XIC.

 */

static void

setXICFocus(XIC ic, unsigned short req)

{

    if (ic == NULL) {

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

        return;

    }

    if (req == 1)

        XSetICFocus(ic);

    else

        XUnsetICFocus(ic);

}

/*

 * Sets the focus window to the given XIC.

 */

static void

setXICWindowFocus(XIC ic, Window w)

{

    if (ic == NULL) {

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

        return;

    }

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

}

/*

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

 * X11InputMethod.dispatchCommittedText() if XmbLookupString() returns

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

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

 *

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

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

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

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

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

 *

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

 */

#define INITIAL_LOOKUP_BUF_SIZE 512

Boolean

awt_x11inputmethod_lookupString(XKeyPressedEvent *event, KeySym *keysymp)

{

    JNIEnv *env = GetJNIEnv();

    X11InputMethodData *pX11IMData = NULL;

    KeySym keysym = NoSymbol;

    Status status;

    int mblen;

    jstring javastr;

    XIC ic;

    Boolean result = True;

    static Boolean composing = False;

    /*

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

     */

    if (!isX11InputMethodGRefInList(currentX11InputMethodInstance)) {

        currentX11InputMethodInstance = NULL;

        return False;

    }

    pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance);

    if (pX11IMData == NULL) {

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

        return False;

#else

        return result;

#endif

    }

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

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

        return False;

#else

        return result;

#endif

    }

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

    if (pX11IMData->lookup_buf_len == 0) {

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

        if (pX11IMData->lookup_buf == NULL) {

            THROW_OUT_OF_MEMORY_ERROR();

            return result;

        }

        pX11IMData->lookup_buf_len = INITIAL_LOOKUP_BUF_SIZE;

    }

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

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

    /*

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

     * XmbLookupString().

     */

    if (status == XBufferOverflow) {

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

        pX11IMData->lookup_buf_len = 0;

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

        if (pX11IMData->lookup_buf == NULL) {

            THROW_OUT_OF_MEMORY_ERROR();

            return result;

        }

        pX11IMData->lookup_buf_len = mblen + 1;

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

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

    }

    pX11IMData->lookup_buf[mblen] = 0;

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