/*

 * Copyright (c) 1995, 2007, 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.

 */

#include "awt_p.h"

#include <sys/time.h>

#include <limits.h>

#include <locale.h>

#ifndef HEADLESS

#include <X11/cursorfont.h>

#include <Xm/MenuShell.h>

#include <Xm/RowColumn.h>

#endif /* !HEADLESS */

#include <jvm.h>

#include <jni.h>

#include <jlong.h>

#include <jni_util.h>

/* JNI headers */

#include "java_awt_AWTEvent.h"

#include "java_awt_Frame.h"

#include "java_awt_SystemColor.h"

#include "sun_awt_motif_MToolkit.h"

/* JNI field and method ids */

#include "awt_Component.h"

//#include "awt_Cursor.h"

#include "awt_MenuComponent.h"

#include "awt_TopLevel.h"

#include "canvas.h"

#include "color.h"

#include "awt_mgrsel.h"

#include "awt_wm.h"

#include "awt_DrawingSurface.h"

#include "awt_Window.h"

#include "awt_xembed.h"

#include "awt_xembed_server.h"

extern JavaVM *jvm;

#ifndef HEADLESS

#ifdef __linux__

extern void statusWindowEventHandler(XEvent event);

#endif

#endif /* !HEADLESS */

JNIEXPORT jint JNICALL

JNI_OnLoad(JavaVM *vm, void *reserved)

{

#ifndef HEADLESS

    awt_util_debug_init();

#endif /* !HEADLESS */

    jvm = vm;

    return JNI_VERSION_1_2;

}

JNIEXPORT jboolean JNICALL AWTIsHeadless() {

#ifdef HEADLESS

    return JNI_TRUE;

#else

    return JNI_FALSE;

#endif

}

#ifndef HEADLESS

static jlong awtJNI_TimeMillis(void);

extern void awt_initialize_Xm_DnD(Display*);

extern void awt_initialize_DataTransferer();

extern Display *awt_init_Display(JNIEnv *env);

extern void X11SD_LibDispose(JNIEnv *env);

extern Widget drag_source = NULL;

extern struct ComponentIDs componentIDs;

extern struct MenuComponentIDs menuComponentIDs;

extern struct MComponentPeerIDs mComponentPeerIDs;

extern struct WindowIDs windowIDs;

static Atom _XA_XSETTINGS_SETTINGS = None;

struct xsettings_callback_cookie {

    jobject mtoolkit;

    jmethodID upcallMID;

};

static struct xsettings_callback_cookie xsettings_callback_cookie;

static XEvent focusOutEvent;

static void awt_pipe_init(void);

static void processOneEvent(XtInputMask iMask);

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

#ifdef USE_SELECT

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

#else

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

#endif

#include <X11/Intrinsic.h>

#include <dlfcn.h>

#include <fcntl.h>

#ifdef USE_SELECT

#if defined(AIX)

#include <sys/select.h>

#endif

#else

#include <poll.h>

#ifndef POLLRDNORM

#define POLLRDNORM POLLIN

#endif

#endif

#ifdef NDEBUG

#undef DEBUG            /* NDEBUG overrides DEBUG */

#endif

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

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

#ifndef bzero

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

#endif

static jboolean syncUpdated = JNI_FALSE;

static jboolean syncFailed = JNI_FALSE;

static jint eventNumber = 0;

static void syncWait_eventHandler(XEvent *);

static Atom oops_atom = None;

static Atom wm_selection = None;

static Atom version_atom = None;

static Boolean inSyncWait = False;

Widget grabbed_widget = NULL;

XtAppContext awt_appContext;

Widget awt_root_shell;

Pixel awt_defaultBg;

Pixel awt_defaultFg;

int32_t awt_multiclick_time;        /* milliseconds */

uint32_t awt_MetaMask = 0;

uint32_t awt_AltMask = 0;

uint32_t awt_NumLockMask = 0;

uint32_t awt_ModeSwitchMask = 0;

Cursor awt_scrollCursor;

Boolean  awt_ModLockIsShiftLock = False;

extern Boolean awt_UseType4Patch;

extern Boolean awt_UseXKB;

#define SPECIAL_KEY_EVENT 2

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

#define PUTBACK_QUEUE_MIN_INCREMENT 5   /* min size increase */

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

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

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

static XtInputMask awt_events_pending(XtAppContext appContext);

static int32_t awt_get_next_put_back_event(XEvent *xev_out);

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

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

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

#define AWT_POLL_BUFSIZE        100

#define AWT_READPIPE            (awt_pipe_fds[0])

#define AWT_WRITEPIPE           (awt_pipe_fds[1])

#define AWT_FLUSHOUTPUT_NOW()  \

{                              \

    XFlush(awt_display);       \

    awt_next_flush_time = 0LL; \

}

typedef XtIntervalId (*XTFUNC)();

static jobject  awt_MainThread = NULL;

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

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

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

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

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

static void     *xt_lib = NULL;

static XTFUNC   xt_timeout = NULL;

#ifdef DEBUG_AWT_LOCK

int32_t awt_locked = 0;

char *lastF = "";

int32_t lastL = -1;

#endif

#ifndef NOMODALFIX

extern Boolean awt_isModal();

extern Boolean awt_isWidgetModal(Widget w);

#endif

Boolean keyboardGrabbed = False;

static uint32_t curPollTimeout = AWT_MAX_POLL_TIMEOUT;

/* Font information to feed Motif widgets. */

static const char      *motifFontList;

static XFontSet        defaultMotifFontSet;

static XFontStruct     *defaultMotifFontStruct;

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

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

XFontSet getMotifFontSet() {

    char    **missingList;

    int32_t     missingCount;

    char    *defChar;

    return XCreateFontSet(awt_display, motifFontList,

                          &missingList, &missingCount, &defChar);

}

XFontStruct *getMotifFontStruct() {

    return XLoadQueryFont(awt_display, defaultMotifFont);

}

XmFontList getMotifFontList() {

    XmFontListEntry motifFontListEntry;

    XmFontList fontlist;

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

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

        if (defaultMotifFontStruct == NULL)

            defaultMotifFontStruct = getMotifFontStruct();

        motifFontListEntry = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG,

                                                   XmFONT_IS_FONT,

                                           (XtPointer)defaultMotifFontStruct);

    }

    else {

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

        if (defaultMotifFontSet == NULL)

            defaultMotifFontSet = getMotifFontSet();

            motifFontListEntry = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG,

                                               XmFONT_IS_FONTSET,

                                               (XtPointer)defaultMotifFontSet);

    }

    fontlist = XmFontListAppendEntry(NULL, motifFontListEntry);

    XmFontListEntryFree(&motifFontListEntry);

    return fontlist;

}

static void

awt_set_poll_timeout (uint32_t newTimeout)

{

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

    newTimeout = max(AWT_MIN_POLL_TIMEOUT, newTimeout);

    newTimeout = min(AWT_MAX_POLL_TIMEOUT, newTimeout);

    newTimeout = min(newTimeout, curPollTimeout);

    curPollTimeout = newTimeout;

} /* awt_set_poll_timeout */

/*

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

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

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

 * next timeout slightly.

 */

static uint32_t

awt_get_poll_timeout( Boolean timedOut )

{

    uint32_t timeout = AWT_MAX_POLL_TIMEOUT;

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

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

        awt_next_flush_time);

    if (timedOut) {

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

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

        curPollTimeout = min(AWT_MAX_POLL_TIMEOUT, curPollTimeout);

    }

    if (awt_next_flush_time > 0) {

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

        timeout = min(curPollTimeout, flushDiff);

    } else {

        timeout = curPollTimeout;

    }

    return timeout;

} /* awt_get_poll_timeout() */

static jlong

awtJNI_TimeMillis(void)

{

    struct timeval t;

    gettimeofday(&t, 0);

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

                     jint_to_jlong(t.tv_usec / 1000));

}

static int32_t

xtError()

{

#ifdef DEBUG

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

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

    JNU_ThrowNullPointerException(env, "NullPointerException");

#endif

    return 0;

}

static int32_t

xIOError(Display *dpy)

{

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

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

    if (errno == EPIPE) {

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

    }

    AWT_NOFLUSH_UNLOCK();

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

    if (cl != NULL) {

        JVM_Sleep(env, cl, 20000);

    }

    return 0; /* to keep compiler happy */

}

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

 * symbol on the keycode returned.  Returns zero otherwise.

 */

static int32_t

keysym_to_keycode_if_primary(Display *dpy, KeySym sym)

{

    KeyCode code;

    KeySym primary;

    code = XKeysymToKeycode(dpy, sym);

    if (code == 0) {

        return 0;

    }

    primary = XKeycodeToKeysym(dpy, code, 0);

    if (sym == primary) {

        return code;

    } else {

        return 0;

    }

}

/*

 * +kb or -kb ?

 */

static Boolean

isXKBenabled(Display *display) {

    int mop, beve, berr;

    /*

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

     */

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

}

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

 * Only consider primary symbols on keycodes attached to modifiers.

 */

static void

setup_modifier_map(Display *disp)

{

    KeyCode metaL      = keysym_to_keycode_if_primary(disp, XK_Meta_L);

    KeyCode metaR      = keysym_to_keycode_if_primary(disp, XK_Meta_R);

    KeyCode altL       = keysym_to_keycode_if_primary(disp, XK_Alt_L);

    KeyCode altR       = keysym_to_keycode_if_primary(disp, XK_Alt_R);

    KeyCode numLock    = keysym_to_keycode_if_primary(disp, XK_Num_Lock);

    KeyCode modeSwitch = keysym_to_keycode_if_primary(disp, XK_Mode_switch);

    KeyCode shiftLock  = keysym_to_keycode_if_primary(disp, XK_Shift_Lock);

    KeyCode capsLock   = keysym_to_keycode_if_primary(disp, XK_Caps_Lock);

    XModifierKeymap *modmap = NULL;

    int32_t nkeys, modn, i;

    char *ptr = NULL;

    DTRACE_PRINTLN("In setup_modifier_map");

    modmap = XGetModifierMapping(disp);

    nkeys = modmap->max_keypermod;

    for (modn = Mod1MapIndex;

         (modn <= Mod5MapIndex) &&

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

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

         ++modn)

    {

        static const uint32_t modmask[8] = {

            ShiftMask, LockMask, ControlMask,

            Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask

        };

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

            /* for each keycode attached to this modifier */

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

            if (keycode == 0) {

                continue;

            }

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

                awt_MetaMask = modmask[modn];

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

                break;

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

                awt_AltMask = modmask[modn];

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

                break;

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

                awt_NumLockMask = modmask[modn];

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

                break;

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

                awt_ModeSwitchMask = modmask[modn];

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

                break;

            }

        }

    }

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

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

        if (keycode == 0) {

            break;

        }

        if (keycode == shiftLock) {

            awt_ModLockIsShiftLock = True;

            break;

        }

        if (keycode == capsLock) {

            break;

        }

    }

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

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

    XFreeModifiermap(modmap);

    ptr = getenv("_AWT_USE_TYPE4_PATCH");

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

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

           awt_UseType4Patch = True;

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

           awt_UseType4Patch = False;

        }

    }

    awt_UseXKB = isXKBenabled(disp);

}

Boolean scrollBugWorkAround;

void

awt_output_flush()

{

    char c = 'p';

    if (awt_next_flush_time == 0)

    {

        Boolean needsWakeup = False;

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

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

            needsWakeup = True;

        }

        /* awt_next_flush_time affects awt_get_poll_timeout(), so set

         * the variable *after* calling the function.

         */

        awt_next_flush_time = awtJNI_TimeMillis() + AWT_FLUSH_TIMEOUT;

        if (needsWakeup)

        {

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

             * loop, if it's sleeping

             */

            write ( AWT_WRITEPIPE, &c, 1 );

        }

    }

#ifdef FLUSHDEBUG

else

jio_fprintf(stderr, "!");

#endif

} /* awt_output_flush() */

void

null_event_handler(Widget w, XtPointer client_data,

                   XEvent * event, Boolean * cont)

{

    /* do nothing */

}

struct WidgetInfo *

findWidgetInfo(Widget widget)

{

    struct WidgetInfo *cw;