/*

 * Copyright (c) 1997, 2018, 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 "awt.h"

#include "awt_p.h"

#include <sun_awt_X11InputMethodBase.h>

#include <sun_awt_X11InputMethod.h>

#include <sun_awt_X11_XInputMethod.h>

#include <langinfo.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/time.h>

#include <wchar.h>

#include <wctype.h>

#include <X11/Intrinsic.h>

#include <X11/keysym.h>

#include <X11/Xlib.h>

#define THROW_OUT_OF_MEMORY_ERROR() \

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

struct X11InputMethodIDs {

  jfieldID pData;

} x11InputMethodIDs;

static int PreeditStartCallback(XIC, XPointer, XPointer);

static void PreeditDoneCallback(XIC, XPointer, XPointer);

static void PreeditDrawCallback(XIC, XPointer,

                                XIMPreeditDrawCallbackStruct *);

static void PreeditCaretCallback(XIC, XPointer,

                                 XIMPreeditCaretCallbackStruct *);

static void StatusStartCallback(XIC, XPointer, XPointer);

static void StatusDoneCallback(XIC, XPointer, XPointer);

static void StatusDrawCallback(XIC, XPointer,

                               XIMStatusDrawCallbackStruct *);

#define ROOT_WINDOW_STYLES      (XIMPreeditNothing | XIMStatusNothing)

#define NO_STYLES               (XIMPreeditNone | XIMStatusNone)

/* added style to allow for in-place composition, such as "dead" keys for accents */

#define IN_PLACE_STYLES         (XIMPreeditNothing | XIMStatusNone)

#define PreeditStartIndex       0

#define PreeditDoneIndex        1

#define PreeditDrawIndex        2

#define PreeditCaretIndex       3

#define StatusStartIndex        4

#define StatusDoneIndex         5

#define StatusDrawIndex         6

#define NCALLBACKS              7

#define STATUS_BORDER 2         /* Status Border width */

#define CARET_OFFSET 1          /* Offset of caret position (pixel) */

#define BORDER_MARGIN 3         /* BORDER MARGIN width */

#define STATUS_MARGIN 7         /* Margin between the status window and its parent window */

#define PREEDIT_ATTR_MASK (XIMReverse|XIMUnderline)

          /* Preedit attribute which host adapter can handle */

/*

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

 * values above.

 */

static XIMProc callback_funcs[NCALLBACKS] = {

    (XIMProc)PreeditDoneCallback,

    (XIMProc)PreeditDrawCallback,

    (XIMProc)PreeditCaretCallback,

    (XIMProc)StatusStartCallback,

    (XIMProc)StatusDoneCallback,

    (XIMProc)StatusDrawCallback,

};

#define MAX_STATUS_LEN  100

typedef struct {

    Window   w;                /*status window id        */

    Window   root;             /*the root window id      */

    Window   parent;           /*parent shell window     */

    Window   grandParent;      /*window has WM frame     */

    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            */

    wchar_t  status[MAX_STATUS_LEN + 1]; /*status text       */

    XFontSet fontset;           /*fontset for drawing    */

    int      off_x, off_y;

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

    int      fOff;              /* font base line(in pixel) from top */

    int      fBot;              /* font bottom line(in pixel) from top */

    int      peTextW;           /* Composition text width in pixel */

    wchar_t* peText;            /* Composed string (wide char.) */

    XIMFeedback* peAttr;        /* Composed text attribute */

    int      peCaret;           /* Caret position in number of character */

    Bool     status_ready;      /* Not draw Status at XCreateIC */

} StatusWindow;

/*

 * 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 */

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

    Bool        passiveStatusWindow;/* Passive Client uses StatusWindow */

    Bool        isActiveClient;     /* True:clinet is active */

    Bool        forceReset;     /* True: call resetXIC before UnsetICFocus */

} X11InputMethodData;

/* 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 X11InputMethodData * getX11InputMethodData(JNIEnv *, jobject);

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

static void destroyX11InputMethodData(JNIEnv *, X11InputMethodData *);

static void freeX11InputMethodData(JNIEnv *, X11InputMethodData *);

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

extern char *XSetIMValues(

#if NeedVarargsPrototypes

    XIM /* im */, ...

#endif

);

static int st_wcslen(wchar_t *string);

static Bool isPreeditStateActive(XIC ic);

static void * buf_insert(void * src, void * insert, int size,

                         int src_len, int ins_len, int offset);

static void * handle_buffer(void * source, void * insert,

                            int size, int src_len, int ins_len,

                            int del_len, int offset);

static void preedit_draw_passive(X11InputMethodData *pX11IMData,

                                 XIMPreeditDrawCallbackStruct *pre_draw);

static void resetPassivePreeditText(StatusWindow *statusWindow);

static void draw_caret(StatusWindow *statusWindow, GC gc, int pos);

static int  get_next_attr(int len, unsigned long *attr);

static void draw_preedit(StatusWindow *statusWindow);

static void align_status(StatusWindow *statusWindow);

static void shrink_status(StatusWindow *statusWindow);

static GC create_gc(Window win, Bool isReverse);

static XFontSet create_fontset(void);

static Bool is_text_available(XIMText * text);

static Bool isNativeIm();

static Window getGrandParent(Window parent);

static void moveStatusWindow(StatusWindow *statusWindow);

static void arrange_window_stack(StatusWindow* statusWindow);

static Window get_current_focus(XIC ic);

/*

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

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

 */

jlong

awt_util_nowMillisUTC()

{

    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;

}

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 (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);

        if (pX11IMData->statusWindow->peText){

            free((void *)pX11IMData->statusWindow->peText);

            pX11IMData->statusWindow->peText = NULL;

        }

        if (pX11IMData->statusWindow->peAttr){

            free((void *)pX11IMData->statusWindow->peAttr);

            pX11IMData->statusWindow->peAttr = NULL;

        }

        free((void*)sw);

    }

    if (pX11IMData->callbacks)

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

    if (env) {

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

    }

    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;

    int buf_len = INITIAL_LOOKUP_BUF_SIZE;

    char mbbuf[INITIAL_LOOKUP_BUF_SIZE];

    char *buf;

    KeySym keysym = NoSymbol;

    Status status;

    int mblen;

    jstring javastr;

    XIC ic;

    Boolean result = True;

    static Boolean composing = False;

    /*

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

     */

    pX11IMData = getX11InputMethodData(env, currentX11InputMethodInstance);

    if (pX11IMData == NULL) {

        return False;

    }

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

        return False;

    }

    buf = mbbuf;

    mblen = XmbLookupString(ic, event, buf,

                            buf_len - 1, &keysym, &status);

    /*

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

     * XmbLookupString().

     */

    if (status == XBufferOverflow) {

        buf_len = mblen + 1;

        buf = (char *)malloc(buf_len);

        if (buf == NULL) {

            THROW_OUT_OF_MEMORY_ERROR();

            return result;

        }

        mblen = XmbLookupString(ic, event, buf, buf_len, &keysym, &status);

    }

    buf[mblen] = 0;

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

     * to AWT keyCode table.

     */

    switch (status) {

    case XLookupBoth:

        if (!composing) {

            if (event->keycode != 0) {

                *keysymp = keysym;

                result = False;

                break;

            }

        }

        composing = False;

        /*FALLTHRU*/

    case XLookupChars:

        /*

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

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

        */

        javastr = JNU_NewStringPlatform(env, (const char *)buf);

        if (javastr != NULL) {

            JNU_CallMethodByName(env, NULL,

                                 currentX11InputMethodInstance,

                                 "dispatchCommittedText",

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

                                 javastr,

                                 event->time);

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

                (*env)->ExceptionDescribe(env);

                (*env)->ExceptionClear(env);

            }

        }

        break;

    case XLookupKeySym:

        /*

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

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

        */

        if (keysym == XK_Multi_key)

            composing = True;

        if (! composing) {

            *keysymp = keysym;

            result = False;

        }

        break;

    case XLookupNone:

        /*

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

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

        */

        break;

    }

    if (buf != mbbuf) {

        free(buf);

    }

    return result;

}

static StatusWindow *createStatusWindow(Window parent) {

    StatusWindow *statusWindow;

    XSetWindowAttributes attrib;

    unsigned long attribmask;

    Window containerWindow;

    Window status;

    Window child;

    XWindowAttributes xwa;

    XWindowAttributes xxwa;

    /* Variable for XCreateFontSet()*/

    char **mclr;

    int  mccr = 0;

    char *dsr;

    unsigned long bg, fg, light, dim;

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

    unsigned int w, h, bw, depth;

    XGCValues values;

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

    int screen = 0;

    int i;

    AwtGraphicsConfigDataPtr adata;

    extern int awt_numScreens;

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

    int width=80, height=22;

    Window rootWindow;

    Window *ignoreWindowPtr;

    unsigned int ignoreUnit;

    Window grandParent;

    Window target;

    XFontSet fontset;