/*

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

 */

#define _JNI_IMPLEMENTATION_

#include "awt.h"

#include <signal.h>

#include <windowsx.h>

#include <process.h>

#include "awt_DrawingSurface.h"

#include "awt_AWTEvent.h"

#include "awt_Component.h"

#include "awt_Canvas.h"

#include "awt_Clipboard.h"

#include "awt_Frame.h"

#include "awt_Dialog.h"

#include "awt_Font.h"

#include "awt_Cursor.h"

#include "awt_InputEvent.h"

#include "awt_KeyEvent.h"

#include "awt_List.h"

#include "awt_Palette.h"

#include "awt_PopupMenu.h"

#include "awt_Toolkit.h"

#include "awt_DesktopProperties.h"

#include "awt_FileDialog.h"

#include "CmdIDList.h"

#include "awt_new.h"

#include "debug_trace.h"

#include "debug_mem.h"

#include "ComCtl32Util.h"

#include "DllUtil.h"

#include "D3DPipelineManager.h"

#include <awt_DnDDT.h>

#include <awt_DnDDS.h>

#include <java_awt_Toolkit.h>

#include <java_awt_event_InputMethodEvent.h>

#include <java_awt_peer_ComponentPeer.h>

extern void initScreens(JNIEnv *env);

extern "C" void awt_dnd_initialize();

extern "C" void awt_dnd_uninitialize();

extern "C" void awt_clipboard_uninitialize(JNIEnv *env);

extern "C" BOOL g_bUserHasChangedInputLang;

extern CriticalSection windowMoveLock;

extern BOOL windowMoveLockHeld;

// Needed by JAWT: see awt_DrawingSurface.cpp.

extern jclass jawtVImgClass;

extern jclass jawtVSMgrClass;

extern jclass jawtComponentClass;

extern jfieldID jawtPDataID;

extern jfieldID jawtSDataID;

extern jfieldID jawtSMgrID;

extern void DWMResetCompositionEnabled();

/************************************************************************

 * Utilities

 */

/* Initialize the Java VM instance variable when the library is

   first loaded */

JavaVM *jvm = NULL;

JNIEXPORT jint JNICALL

JNI_OnLoad(JavaVM *vm, void *reserved)

{

    TRY;

    jvm = vm;

    return JNI_VERSION_1_2;

    CATCH_BAD_ALLOC_RET(0);

}

extern "C" JNIEXPORT jboolean JNICALL AWTIsHeadless() {

    static JNIEnv *env = NULL;

    static jboolean isHeadless;

    jmethodID headlessFn;

    jclass graphicsEnvClass;

    if (env == NULL) {

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

        graphicsEnvClass = env->FindClass(

            "java/awt/GraphicsEnvironment");

        if (graphicsEnvClass == NULL) {

            return JNI_TRUE;

        }

        headlessFn = env->GetStaticMethodID(

            graphicsEnvClass, "isHeadless", "()Z");

        if (headlessFn == NULL) {

            return JNI_TRUE;

        }

        isHeadless = env->CallStaticBooleanMethod(graphicsEnvClass,

            headlessFn);

    }

    return isHeadless;

}

#define IDT_AWT_MOUSECHECK 0x101

static LPCTSTR szAwtToolkitClassName = TEXT("SunAwtToolkit");

static const int MOUSE_BUTTONS_WINDOWS_SUPPORTED = 5; //three standard buttons + XBUTTON1 + XBUTTON2.

UINT AwtToolkit::GetMouseKeyState()

{

    static BOOL mbSwapped = ::GetSystemMetrics(SM_SWAPBUTTON);

    UINT mouseKeyState = 0;

    if (HIBYTE(::GetKeyState(VK_CONTROL)))

        mouseKeyState |= MK_CONTROL;

    if (HIBYTE(::GetKeyState(VK_SHIFT)))

        mouseKeyState |= MK_SHIFT;

    if (HIBYTE(::GetKeyState(VK_LBUTTON)))

        mouseKeyState |= (mbSwapped ? MK_RBUTTON : MK_LBUTTON);

    if (HIBYTE(::GetKeyState(VK_RBUTTON)))

        mouseKeyState |= (mbSwapped ? MK_LBUTTON : MK_RBUTTON);

    if (HIBYTE(::GetKeyState(VK_MBUTTON)))

        mouseKeyState |= MK_MBUTTON;

    return mouseKeyState;

}

//

// Normal ::GetKeyboardState call only works if current thread has

// a message pump, so provide a way for other threads to get

// the keyboard state

//

void AwtToolkit::GetKeyboardState(PBYTE keyboardState)

{

    CriticalSection::Lock       l(AwtToolkit::GetInstance().m_lockKB);

    DASSERT(!IsBadWritePtr(keyboardState, KB_STATE_SIZE));

    memcpy(keyboardState, AwtToolkit::GetInstance().m_lastKeyboardState,

           KB_STATE_SIZE);

}

void AwtToolkit::SetBusy(BOOL busy) {

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

    static jclass awtAutoShutdownClass = NULL;

    static jmethodID notifyBusyMethodID = NULL;

    static jmethodID notifyFreeMethodID = NULL;

    if (awtAutoShutdownClass == NULL) {

        jclass awtAutoShutdownClassLocal = env->FindClass("sun/awt/AWTAutoShutdown");

        if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {

            env->ExceptionDescribe();

            env->ExceptionClear();

        }

        DASSERT(awtAutoShutdownClassLocal != NULL);

        if (awtAutoShutdownClassLocal == NULL) {

            return;

        }

        awtAutoShutdownClass = (jclass)env->NewGlobalRef(awtAutoShutdownClassLocal);

        env->DeleteLocalRef(awtAutoShutdownClassLocal);

        notifyBusyMethodID = env->GetStaticMethodID(awtAutoShutdownClass,

                                                    "notifyToolkitThreadBusy", "()V");

        if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {

            env->ExceptionDescribe();

            env->ExceptionClear();

        }

        notifyFreeMethodID = env->GetStaticMethodID(awtAutoShutdownClass,

                                                    "notifyToolkitThreadFree", "()V");

        if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {

            env->ExceptionDescribe();

            env->ExceptionClear();

        }

        DASSERT(notifyBusyMethodID != NULL);

        DASSERT(notifyFreeMethodID != NULL);

        if (notifyBusyMethodID == NULL || notifyFreeMethodID == NULL) {

            return;

        }

    } /* awtAutoShutdownClass == NULL*/

    if (busy) {

        env->CallStaticVoidMethod(awtAutoShutdownClass,

                                  notifyBusyMethodID);

    } else {

        env->CallStaticVoidMethod(awtAutoShutdownClass,

                                  notifyFreeMethodID);

    }

    if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {

        env->ExceptionDescribe();

        env->ExceptionClear();

    }

}

BOOL AwtToolkit::activateKeyboardLayout(HKL hkl) {

    // This call should succeed in case of one of the following:

    // 1. Win 9x

    // 2. NT with that HKL already loaded

    HKL prev = ::ActivateKeyboardLayout(hkl, 0);

    // If the above call fails, try loading the layout in case of NT

    if (!prev) {

        // create input locale string, e.g., "00000409", from hkl.

        TCHAR inputLocale[9];

        TCHAR buf[9];

        _tcscpy(inputLocale, TEXT("00000000"));

    // 64-bit: ::LoadKeyboardLayout() is such a weird API - a string of

    // the hex value you want?!  Here we're converting our HKL value to

    // a string.  Hopefully there is no 64-bit trouble.

        _i64tot(reinterpret_cast<INT_PTR>(hkl), buf, 16);

        size_t len = _tcslen(buf);

        memcpy(&inputLocale[8-len], buf, len);

        // load and activate the keyboard layout

        hkl = ::LoadKeyboardLayout(inputLocale, 0);

        if (hkl != 0) {

            prev = ::ActivateKeyboardLayout(hkl, 0);

        }

    }

    return (prev != 0);

}

/************************************************************************

 * Exported functions

 */

extern "C" BOOL APIENTRY DllMain(HANDLE hInstance, DWORD ul_reason_for_call,

                                 LPVOID)

{

    // Don't use the TRY and CATCH_BAD_ALLOC_RET macros if we're detaching

    // the library. Doing so causes awt.dll to call back into the VM during

    // shutdown. This crashes the HotSpot VM.

    switch (ul_reason_for_call) {

    case DLL_PROCESS_ATTACH:

        TRY;

        AwtToolkit::GetInstance().SetModuleHandle((HMODULE)hInstance);

        CATCH_BAD_ALLOC_RET(FALSE);

        break;

    case DLL_PROCESS_DETACH:

#ifdef DEBUG

        DTrace_DisableMutex();

        DMem_DisableMutex();

#endif DEBUG

        break;

    }

    return TRUE;

}

/************************************************************************

 * AwtToolkit fields

 */

AwtToolkit AwtToolkit::theInstance;

/* ids for WToolkit fields accessed from native code */

jmethodID AwtToolkit::windowsSettingChangeMID;

jmethodID AwtToolkit::displayChangeMID;

/* ids for Toolkit methods */

jmethodID AwtToolkit::getDefaultToolkitMID;

jmethodID AwtToolkit::getFontMetricsMID;

jmethodID AwtToolkit::insetsMID;

/************************************************************************

 * AwtToolkit methods

 */

AwtToolkit::AwtToolkit() {

    m_localPump = FALSE;

    m_mainThreadId = 0;

    m_toolkitHWnd = NULL;

    m_inputMethodHWnd = NULL;

    m_verbose = FALSE;

    m_isActive = TRUE;

    m_isDisposed = FALSE;

    m_vmSignalled = FALSE;

    m_isDynamicLayoutSet = FALSE;

    m_areExtraMouseButtonsEnabled = TRUE;

    m_verifyComponents = FALSE;

    m_breakOnError = FALSE;

    m_breakMessageLoop = FALSE;

    m_messageLoopResult = 0;

    m_lastMouseOver = NULL;

    m_mouseDown = FALSE;

    m_hGetMessageHook = 0;

    m_hMouseLLHook = 0;

    m_lastWindowUnderMouse = NULL;

    m_timer = 0;

    m_cmdIDs = new AwtCmdIDList();

    m_pModalDialog = NULL;

    m_peer = NULL;

    m_dllHandle = NULL;

    m_displayChanged = FALSE;

    m_embedderProcessID = 0;

    // XXX: keyboard mapping should really be moved out of AwtComponent

    AwtComponent::InitDynamicKeyMapTable();

    // initialize kb state array

    ::GetKeyboardState(m_lastKeyboardState);

    m_waitEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);

    eventNumber = 0;

}

AwtToolkit::~AwtToolkit() {

/*

 *  The code has been moved to AwtToolkit::Dispose() method.

 */

}

HWND AwtToolkit::CreateToolkitWnd(LPCTSTR name)

{

    HWND hwnd = CreateWindow(

        szAwtToolkitClassName,

        (LPCTSTR)name,                    /* window name */

        WS_DISABLED,                      /* window style */

        -1, -1,                           /* position of window */

        0, 0,                             /* width and height */

        NULL, NULL,                       /* hWndParent and hWndMenu */

        GetModuleHandle(),

        NULL);                            /* lpParam */

    DASSERT(hwnd != NULL);

    return hwnd;

}

struct ToolkitThreadProc_Data {

    bool result;

    HANDLE hCompleted;

    jobject thread;

};

void ToolkitThreadProc(void *param)

{

    ToolkitThreadProc_Data *data = (ToolkitThreadProc_Data *)param;

    bool bNotified = false;

    JNIEnv *env;

    JavaVMAttachArgs attachArgs;

    attachArgs.version  = JNI_VERSION_1_2;

    attachArgs.name     = "AWT-Windows";

    attachArgs.group    = NULL;

    jint res = jvm->AttachCurrentThreadAsDaemon((void **)&env, &attachArgs);

    if (res < 0) {

        return;

    }

    jobject thread = env->NewGlobalRef(data->thread);

    if (thread != NULL) {

        jclass cls = env->GetObjectClass(thread);

        if (cls != NULL) {

            jmethodID runId = env->GetMethodID(cls, "run", "()V");

            if (runId != NULL) {

                data->result = true;

                ::SetEvent(data->hCompleted);

                bNotified = true;

                env->CallVoidMethod(thread, runId);

                if (env->ExceptionCheck()) {

                    env->ExceptionDescribe();

                    env->ExceptionClear();

                    // TODO: handle

                }

            }

            env->DeleteLocalRef(cls);

        }

        env->DeleteGlobalRef(thread);

    }

    if (!bNotified) {

        ::SetEvent(data->hCompleted);

    }

    jvm->DetachCurrentThread();

}

/*

 * Class:     sun_awt_windows_WToolkit

 * Method:    startToolkitThread

 * Signature: (Ljava/lang/Runnable;)Z

 */

JNIEXPORT jboolean JNICALL

Java_sun_awt_windows_WToolkit_startToolkitThread(JNIEnv *env, jclass cls, jobject thread)

{

    AwtToolkit& tk = AwtToolkit::GetInstance();

    ToolkitThreadProc_Data data;

    data.result = false;

    data.thread = env->NewGlobalRef(thread);

    if (data.thread == NULL) {

        return JNI_FALSE;

    }

    data.hCompleted = ::CreateEvent(NULL, FALSE, FALSE, NULL);

    bool result = tk.GetPreloadThread()

                    .InvokeAndTerminate(ToolkitThreadProc, &data);

    if (result) {

        ::WaitForSingleObject(data.hCompleted, INFINITE);

        result = data.result;

    } else {

        // no awt preloading

        // return back to the usual toolkit way

    }

    ::CloseHandle(data.hCompleted);

    env->DeleteGlobalRef(data.thread);

    return result ? JNI_TRUE : JNI_FALSE;

}

BOOL AwtToolkit::Initialize(BOOL localPump) {

    AwtToolkit& tk = AwtToolkit::GetInstance();

    if (!tk.m_isActive || tk.m_mainThreadId != 0) {

        /* Already initialized. */

        return FALSE;

    }

    // This call is moved here from AwtToolkit constructor. Having it

    // there led to the bug 6480630: there could be a situation when

    // ComCtl32Util was constructed but not disposed

    ComCtl32Util::GetInstance().InitLibraries();

    if (!localPump) {

        // if preload thread was run, terminate it

        preloadThread.Terminate(true);

    }

    /* Register this toolkit's helper window */

    VERIFY(tk.RegisterClass() != NULL);

    // Set up operator new/malloc out of memory handler.

    NewHandler::init();

        //\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

        // Bugs 4032109, 4047966, and 4071991 to fix AWT

        //      crash in 16 color display mode.  16 color mode is supported.  Less

        //      than 16 color is not.

        // creighto@eng.sun.com 1997-10-07

        //

        // Check for at least 16 colors

    HDC hDC = ::GetDC(NULL);

        if ((::GetDeviceCaps(hDC, BITSPIXEL) * ::GetDeviceCaps(hDC, PLANES)) < 4) {

                ::MessageBox(NULL,

                             TEXT("Sorry, but this release of Java requires at least 16 colors"),

                             TEXT("AWT Initialization Error"),

                             MB_ICONHAND | MB_APPLMODAL);

                ::DeleteDC(hDC);

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

                JNU_ThrowByName(env, "java/lang/InternalError",

                                "unsupported screen depth");

                return FALSE;

        }

    ::ReleaseDC(NULL, hDC);

        ///////////////////////////////////////////////////////////////////////////

    tk.m_localPump = localPump;

    tk.m_mainThreadId = ::GetCurrentThreadId();

    /*

     * Create the one-and-only toolkit window.  This window isn't

     * displayed, but is used to route messages to this thread.

     */

    tk.m_toolkitHWnd = tk.CreateToolkitWnd(TEXT("theAwtToolkitWindow"));

    DASSERT(tk.m_toolkitHWnd != NULL);

    /*

     * Setup a GetMessage filter to watch all messages coming out of our

     * queue from PreProcessMsg().

     */

    tk.m_hGetMessageHook = ::SetWindowsHookEx(WH_GETMESSAGE,

                                              (HOOKPROC)GetMessageFilter,

                                              0, tk.m_mainThreadId);

    awt_dnd_initialize();

    return TRUE;

}