/*

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

#include <shlwapi.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>

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;

jobject reasonUnspecified;

jobject reasonConsole;

jobject reasonRemote;

jobject reasonLock;

extern jobject GetStaticObject(JNIEnv *env, jclass wfClass, const char *fieldName,

                        const char *signature);

extern BOOL isSuddenTerminationEnabled;

extern void DWMResetCompositionEnabled();

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

 * Utilities

 */

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

   first loaded */

JavaVM *jvm = NULL;

JNIEXPORT jint JNICALL

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

        DASSERT(awtAutoShutdownClassLocal != NULL);

        if (!awtAutoShutdownClassLocal) throw std::bad_alloc();

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

        env->DeleteLocalRef(awtAutoShutdownClassLocal);

        if (!awtAutoShutdownClass) throw std::bad_alloc();

        notifyBusyMethodID = env->GetStaticMethodID(awtAutoShutdownClass,

                                                    "notifyToolkitThreadBusy", "()V");

        DASSERT(notifyBusyMethodID != NULL);

        if (!notifyBusyMethodID) throw std::bad_alloc();

        notifyFreeMethodID = env->GetStaticMethodID(awtAutoShutdownClass,

                                                    "notifyToolkitThreadFree", "()V");

        DASSERT(notifyFreeMethodID != NULL);

        if (!notifyFreeMethodID) throw std::bad_alloc();

    } /* 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_s(inputLocale, 9, 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;

jmethodID AwtToolkit::userSessionMID;

jmethodID AwtToolkit::systemSleepMID;

/* 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_isWin8OrLater = FALSE;

    m_touchKbrdAutoShowIsEnabled = FALSE;

    m_touchKbrdExeFilePath = NULL;

    m_pRegisterTouchWindow = NULL;

    m_pGetTouchInputInfo = NULL;

    m_pCloseTouchInputHandle = NULL;

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

    isInDoDragDropLoop = FALSE;

    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;

}

void AwtToolkit::InitTouchKeyboardExeFilePath() {

    enum RegistryView { WOW64_32BIT, WOW64_64BIT };

    const TCHAR tabTipCoKeyName[] = _T("SOFTWARE\\Classes\\CLSID\\")

        _T("{054AAE20-4BEA-4347-8A35-64A533254A9D}\\LocalServer32");

    HKEY hTabTipCoKey = NULL;

    RegistryView regViewWithTabTipCoKey = WOW64_32BIT;

    if (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, tabTipCoKeyName, 0,

            KEY_READ | KEY_WOW64_32KEY, &hTabTipCoKey) != ERROR_SUCCESS) {

        if (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, tabTipCoKeyName, 0,

                KEY_READ | KEY_WOW64_64KEY, &hTabTipCoKey) != ERROR_SUCCESS) {

            return;

        } else {

            regViewWithTabTipCoKey = WOW64_64BIT;

        }

    }

    DWORD keyValType = 0;

    DWORD bytesCopied = 0;

    if ((::RegQueryValueEx(hTabTipCoKey, NULL, NULL, &keyValType, NULL,

            &bytesCopied) != ERROR_SUCCESS) ||

        ((keyValType != REG_EXPAND_SZ) && (keyValType != REG_SZ))) {

        if (hTabTipCoKey != NULL) {

            ::RegCloseKey(hTabTipCoKey);

        }

        return;

    }

    // Increase the buffer size for 1 additional null-terminating character.

    bytesCopied += sizeof(TCHAR);

    TCHAR* tabTipFilePath = new TCHAR[bytesCopied / sizeof(TCHAR)];

    ::memset(tabTipFilePath, 0, bytesCopied);

    DWORD oldBytesCopied = bytesCopied;

    if (::RegQueryValueEx(hTabTipCoKey, NULL, NULL, NULL,

            (LPBYTE)tabTipFilePath, &bytesCopied) == ERROR_SUCCESS) {

        const TCHAR searchedStr[] = _T("%CommonProgramFiles%");

        const size_t searchedStrLen = ::_tcslen(searchedStr);

        int searchedStrStartIndex = -1;

        TCHAR* commonFilesDirPath = NULL;

        DWORD commonFilesDirPathLen = 0;

        // Check, if '%CommonProgramFiles%' string is present in the defined

        // path of the touch keyboard executable.

        TCHAR* const searchedStrStart = ::_tcsstr(tabTipFilePath, searchedStr);

        if (searchedStrStart != NULL) {

            searchedStrStartIndex = searchedStrStart - tabTipFilePath;

            // Get value of 'CommonProgramFiles' environment variable, if the

            // file path of the touch keyboard executable was found in 32-bit

            // registry view, otherwise get value of 'CommonProgramW6432'.

            const TCHAR envVar32BitName[] = _T("CommonProgramFiles");

            const TCHAR envVar64BitName[] = _T("CommonProgramW6432");

            const TCHAR* envVarName = (regViewWithTabTipCoKey == WOW64_32BIT ?

                envVar32BitName : envVar64BitName);

            DWORD charsStored = ::GetEnvironmentVariable(envVarName, NULL, 0);

            if (charsStored > 0) {

                commonFilesDirPath = new TCHAR[charsStored];

                ::memset(commonFilesDirPath, 0, charsStored * sizeof(TCHAR));

                DWORD oldCharsStored = charsStored;

                if (((charsStored = ::GetEnvironmentVariable(envVarName,

                        commonFilesDirPath, charsStored)) > 0) &&

                    (charsStored <= oldCharsStored)) {

                    commonFilesDirPathLen = charsStored;

                } else {

                    delete[] commonFilesDirPath;

                    commonFilesDirPath = NULL;

                }

            }

        }

        // Calculate 'm_touchKbrdExeFilePath' length in characters including

        // the null-terminating character.

        DWORD exeFilePathLen = oldBytesCopied / sizeof(TCHAR);

        if (commonFilesDirPathLen > 0) {

            exeFilePathLen = exeFilePathLen - searchedStrLen +

                commonFilesDirPathLen;

        }

        if (m_touchKbrdExeFilePath != NULL) {

            delete[] m_touchKbrdExeFilePath;

            m_touchKbrdExeFilePath = NULL;

        }

        m_touchKbrdExeFilePath = new TCHAR[exeFilePathLen];

        ::memset(m_touchKbrdExeFilePath, 0, exeFilePathLen * sizeof(TCHAR));

        if (commonFilesDirPathLen > 0) {

            ::_tcsncpy_s(m_touchKbrdExeFilePath, exeFilePathLen, tabTipFilePath,

                searchedStrStartIndex);

            DWORD charsCopied = searchedStrStartIndex;

            ::_tcsncpy_s(m_touchKbrdExeFilePath + charsCopied,

                exeFilePathLen - charsCopied, commonFilesDirPath,

                commonFilesDirPathLen);

            charsCopied += commonFilesDirPathLen;

            ::_tcsncpy_s(m_touchKbrdExeFilePath + charsCopied,

                exeFilePathLen - charsCopied, searchedStrStart + searchedStrLen,

                bytesCopied / sizeof(TCHAR) -

                    (searchedStrStartIndex + searchedStrLen));

        } else {

            ::_tcsncpy_s(m_touchKbrdExeFilePath, exeFilePathLen, tabTipFilePath,

                bytesCopied / sizeof(TCHAR));

        }

        // Remove leading and trailing quotation marks.

        ::StrTrim(m_touchKbrdExeFilePath, _T("\""));

        // Verify that a file with the path 'm_touchKbrdExeFilePath' exists.

        DWORD fileAttrs = ::GetFileAttributes(m_touchKbrdExeFilePath);

        DWORD err = ::GetLastError();

        if ((fileAttrs == INVALID_FILE_ATTRIBUTES) ||

            (fileAttrs & FILE_ATTRIBUTE_DIRECTORY)) {

            delete[] m_touchKbrdExeFilePath;

            m_touchKbrdExeFilePath = NULL;

        }

        if (commonFilesDirPath != NULL) {

            delete[] commonFilesDirPath;

        }

    }

    if (tabTipFilePath != NULL) {

        delete[] tabTipFilePath;

    }

    if (hTabTipCoKey != NULL) {

        ::RegCloseKey(hTabTipCoKey);

    }

}

HWND AwtToolkit::GetTouchKeyboardWindow() {

    const TCHAR wndClassName[] = _T("IPTip_Main_Window");

    HWND hwnd = ::FindWindow(wndClassName, NULL);

    if ((hwnd != NULL) && ::IsWindow(hwnd) && ::IsWindowEnabled(hwnd)) {

        return hwnd;

    }

    return NULL;

}