/*

 * Copyright 2002-2006 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/Xos.h>

#include <X11/Xatom.h>

#ifdef __linux__

#include <execinfo.h>

#endif

#include <jvm.h>

#include <jni.h>

#include <jlong.h>

#include <jni_util.h>

#include "awt_p.h"

#include "awt_Component.h"

#include "awt_MenuComponent.h"

#include "awt_KeyboardFocusManager.h"

#include "awt_Font.h"

#include "sun_awt_X11_XToolkit.h"

#include "java_awt_SystemColor.h"

#include "java_awt_TrayIcon.h"

uint32_t awt_NumLockMask = 0;

Boolean  awt_ModLockIsShiftLock = False;

extern JavaVM *jvm;

// Tracing level

static int tracing = 0;

#ifdef PRINT

#undef PRINT

#endif

#ifdef PRINT2

#undef PRINT2

#endif

#define PRINT if (tracing) printf

#define PRINT2 if (tracing > 1) printf

struct ComponentIDs componentIDs;

struct MenuComponentIDs menuComponentIDs;

struct KeyboardFocusManagerIDs keyboardFocusManagerIDs;

#ifndef HEADLESS

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

extern struct MFontPeerIDs mFontPeerIDs;

JNIEXPORT void JNICALL

Java_sun_awt_X11_XFontPeer_initIDs

  (JNIEnv *env, jclass cls)

{

    mFontPeerIDs.xfsname =

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

}

#endif /* !HEADLESS */

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

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

JNIEXPORT void JNICALL

Java_java_awt_FileDialog_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_sun_awt_X11_XToolkit_initIDs

  (JNIEnv *env, jclass clazz)

{

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

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

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

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

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

}

/*

 * Class:     sun_awt_X11_XToolkit

 * Method:    getDefaultXColormap

 * Signature: ()J

 */

JNIEXPORT jlong JNICALL Java_sun_awt_X11_XToolkit_getDefaultXColormap

  (JNIEnv *env, jclass clazz)

{

    AwtGraphicsConfigDataPtr defaultConfig =

        getDefaultConfig(DefaultScreen(awt_display));

    return (jlong) defaultConfig->awt_cmap;

}

JNIEXPORT jlong JNICALL Java_sun_awt_X11_XToolkit_getDefaultScreenData

  (JNIEnv *env, jclass clazz)

{

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

}

JNIEXPORT jint JNICALL

JNI_OnLoad(JavaVM *vm, void *reserved)

{

    jvm = vm;

    return JNI_VERSION_1_2;

}

/*

 * Class:     sun_awt_X11_XToolkit

 * Method:    nativeLoadSystemColors

 * Signature: ([I)V

 */

JNIEXPORT void JNICALL Java_sun_awt_X11_XToolkit_nativeLoadSystemColors

  (JNIEnv *env, jobject this, jintArray systemColors)

{

    AwtGraphicsConfigDataPtr defaultConfig =

        getDefaultConfig(DefaultScreen(awt_display));

    awtJNI_CreateColorData(env, defaultConfig, 1);

}

JNIEXPORT void JNICALL

Java_java_awt_Component_initIDs

  (JNIEnv *env, jclass cls)

{

    jclass keyclass = NULL;

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

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

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

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

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

    componentIDs.peer =

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

    componentIDs.background =

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

    componentIDs.foreground =

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

    componentIDs.graphicsConfig =

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

                           "Ljava/awt/GraphicsConfiguration;");

    componentIDs.name =

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

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

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

     */

    componentIDs.getParent =

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

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

    componentIDs.getLocationOnScreen =

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

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

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

    DASSERT (keyclass != NULL);

    componentIDs.isProxyActive =

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

                           "Z");

    componentIDs.appContext =

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

                           "Lsun/awt/AppContext;");

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

}

JNIEXPORT void JNICALL

Java_java_awt_Container_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_Button_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_Scrollbar_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_Window_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_Frame_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_MenuComponent_initIDs(JNIEnv *env, jclass cls)

{

    menuComponentIDs.appContext =

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

}

JNIEXPORT void JNICALL

Java_java_awt_Cursor_initIDs(JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL Java_java_awt_MenuItem_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL Java_java_awt_Menu_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_TextArea_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_Checkbox_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL Java_java_awt_ScrollPane_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT void JNICALL

Java_java_awt_TextField_initIDs

  (JNIEnv *env, jclass cls)

{

}

JNIEXPORT jboolean JNICALL AWTIsHeadless() {

#ifdef HEADLESS

    return JNI_TRUE;

#else

    return JNI_FALSE;

#endif

}

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

{

}

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

// Includes

#include <sys/time.h>

#include <limits.h>

#include <locale.h>

#include <pthread.h>

#include <dlfcn.h>

#include <fcntl.h>

#include <poll.h>

#ifndef POLLRDNORM

#define POLLRDNORM POLLIN

#endif

// Prototypes

static void     waitForEvents(JNIEnv *, jlong);

static void     awt_pipe_init();

static void     processOneEvent(XtInputMask iMask);

static void     performPoll(JNIEnv *, jlong);

static void     wakeUp();

static void     update_poll_timeout(int timeout_control);

static uint32_t get_poll_timeout(jlong nextTaskTime);

// Defines

#ifndef bzero

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

#endif

#define AWT_POLL_BUFSIZE        100 /* bytes */

#define AWT_READPIPE            (awt_pipe_fds[0])

#define AWT_WRITEPIPE           (awt_pipe_fds[1])

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

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

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

#define TIMEOUT_TIMEDOUT 0

#define TIMEOUT_EVENTS 1

// Static fields

static uint32_t AWT_FLUSH_TIMEOUT  =  DEF_AWT_FLUSH_TIMEOUT; /* milliseconds */

static uint32_t AWT_MAX_POLL_TIMEOUT = DEF_AWT_MAX_POLL_TIMEOUT; /* milliseconds */

static pthread_t    awt_MainThread = 0;

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 jlong        awt_next_flush_time = 0LL; /* 0 == no scheduled flush */

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

static uint32_t     curPollTimeout;

static struct pollfd pollFds[2];

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

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

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

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

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

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

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

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

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

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

// to 0).

static int32_t static_poll_timeout = 0;

static Bool isMainThread() {

    return awt_MainThread == pthread_self();

}

/*

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

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

 * select() by writing to this pipe.

 */

static void

awt_pipe_init() {

    if (awt_pipe_inited) {

        return;

    }

    if ( pipe ( awt_pipe_fds ) == 0 )

    {

        /*

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

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

        ** flush.

        */

        int32_t flags = 0;

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

        flags = fcntl ( AWT_READPIPE, F_GETFL, 0 );

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

        flags = fcntl ( AWT_WRITEPIPE, F_GETFL, 0 );

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

        awt_pipe_inited = True;

    }

    else

    {

        AWT_READPIPE = -1;

        AWT_WRITEPIPE = -1;

    }

} /* awt_pipe_init() */

/**

 * Reads environment variables to initialize timeout fields.

 */

static void readEnv() {

    char * value;

    static Boolean env_read = False;

    if (env_read) return;

    env_read = True;

    value = getenv("_AWT_MAX_POLL_TIMEOUT");

    if (value != NULL) {

        AWT_MAX_POLL_TIMEOUT = atoi(value);

        if (AWT_MAX_POLL_TIMEOUT == 0) {

            AWT_MAX_POLL_TIMEOUT = DEF_AWT_MAX_POLL_TIMEOUT;

        }

    }

    curPollTimeout = AWT_MAX_POLL_TIMEOUT/2;

    value = getenv("_AWT_FLUSH_TIMEOUT");

    if (value != NULL) {

        AWT_FLUSH_TIMEOUT = atoi(value);

        if (AWT_FLUSH_TIMEOUT == 0) {

            AWT_FLUSH_TIMEOUT = DEF_AWT_FLUSH_TIMEOUT;

        }

    }

    value = getenv("_AWT_POLL_TRACING");

    if (value != NULL) {

        tracing = atoi(value);

    }

    value = getenv("_AWT_STATIC_POLL_TIMEOUT");

    if (value != NULL) {

        static_poll_timeout = atoi(value);

    }

    if (static_poll_timeout != 0) {

        curPollTimeout = static_poll_timeout;

    }

}

/**

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

 */

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

}

/**

 * Updates curPollTimeout according to the aging algorithm.

 * @param timeout_control Either TIMEOUT_TIMEDOUT or TIMEOUT_EVENTS

 */

static void update_poll_timeout(int timeout_control) {

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

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

    if (static_poll_timeout != 0) return;

    // Update it otherwise

    if (timeout_control == TIMEOUT_TIMEDOUT) {

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

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

        curPollTimeout = min(AWT_MAX_POLL_TIMEOUT, curPollTimeout);

    } else if (timeout_control == TIMEOUT_EVENTS) {

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

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

        curPollTimeout = max(AWT_MIN_POLL_TIMEOUT, curPollTimeout);

    }

}

/*

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

 *

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

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

 */

static uint32_t get_poll_timeout(jlong nextTaskTime)

{

    jlong curTime = awtJNI_TimeMillis();

    uint32_t timeout = curPollTimeout;

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

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

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

    // Adjust timeout to flush_time and task_time

    return min(flushTimeout, min(taskTimeout, timeout));

} /* awt_get_poll_timeout() */

/*

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

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

 * be processed.

 *

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

 * awt_next_flush_time has been reached.

 *

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

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

 */

void

waitForEvents(JNIEnv *env, jlong nextTaskTime) {

    performPoll(env, nextTaskTime);

    if ((awt_next_flush_time > 0) && (awtJNI_TimeMillis() >= awt_next_flush_time)) {

        XFlush(awt_display);

        awt_last_flush_time = awt_next_flush_time;

        awt_next_flush_time = 0LL;

    }

} /* waitForEvents() */

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

    waitForEvents(env, nextTaskTime);

}