C4WindowWin32.cpp

Go to the documentation of this file.

/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 1998-2000, Matthes Bender
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2009-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
 
/* A wrapper class to OS dependent event and window interfaces, WIN32 version */
 
#include "C4Include.h"
#include "C4ForbidLibraryCompilation.h"
#include "platform/C4Window.h"
 
#include "C4Version.h"
#include "editor/C4Console.h"
#include "editor/C4ViewportWindow.h"
#include "game/C4Application.h"
#include "game/C4FullScreen.h"
#include "game/C4GraphicsSystem.h"
#include "game/C4Viewport.h"
#include "graphics/C4DrawGL.h"
#include "gui/C4MouseControl.h"
#include "lib/C4Rect.h"
#include "platform/C4AppWin32Impl.h"
#include "platform/StdRegistry.h"
#include "res/resource.h"
 
#include "platform/C4windowswrapper.h"
#include <mmsystem.h>
#include <shellapi.h>
 
#define C4ViewportClassName L"C4Viewport"
#define C4FullScreenClassName L"C4FullScreen"
#define ConsoleDlgClassName L"C4GUIdlg"
#define ConsoleDlgWindowStyle (WS_VISIBLE | WS_POPUP | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX)
 
static void ConvertToUnixScancode(WPARAM wParam, C4KeyCode *scancode, bool extended)
{
    C4KeyCode &s = *scancode;
 
    switch(wParam)
    {
    case VK_HOME:       s = K_HOME; break;
    case VK_END:        s = K_END; break;
    case VK_PRIOR:      s = K_PAGEUP; break;
    case VK_NEXT:       s = K_PAGEDOWN; break;
    case VK_UP:         s = K_UP; break;
    case VK_DOWN:       s = K_DOWN; break;
    case VK_LEFT:       s = K_LEFT; break;
    case VK_RIGHT:      s = K_RIGHT; break;
    case VK_CLEAR:      s = K_CENTER; break;
    case VK_INSERT:     s = K_INSERT; break;
    case VK_DELETE:     s = K_DELETE; break;
    case VK_LWIN:       s = K_WIN_L; break;
    case VK_RWIN:       s = K_WIN_R; break;
    case VK_MENU:       s = K_MENU; break;
    case VK_PAUSE:      s = K_PAUSE; break;
    case VK_PRINT:      s = K_PRINT; break;
    case VK_RCONTROL:   s = K_CONTROL_R; break;
    case VK_CONTROL:    s = (extended ? K_CONTROL_R : K_CONTROL_L); break;
    case VK_NUMLOCK:    s = K_NUM; break;
    case VK_NUMPAD1:    s = K_NUM1; break;
    case VK_NUMPAD2:    s = K_NUM2; break;
    case VK_NUMPAD3:    s = K_NUM3; break;
    case VK_NUMPAD4:    s = K_NUM4; break;
    case VK_NUMPAD5:    s = K_NUM5; break;
    case VK_NUMPAD6:    s = K_NUM6; break;
    case VK_NUMPAD7:    s = K_NUM7; break;
    case VK_NUMPAD8:    s = K_NUM8; break;
    case VK_NUMPAD9:    s = K_NUM9; break;
    case VK_NUMPAD0:    s = K_NUM0; break;
    }
}
 
LRESULT APIENTRY FullScreenWinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    static bool NativeCursorShown = true;
 
    POINT p;
    p.x = GET_X_LPARAM(lParam);
    p.y = GET_Y_LPARAM(lParam);
 
    // compute scancode
    C4KeyCode scancode = (((unsigned int)lParam) >> 16) & 0xFF;
    bool extended = ((lParam & 0x01000000) != 0);
    ConvertToUnixScancode(wParam, &scancode, extended);
 
    // Process message
    switch (uMsg)
    {
    case WM_ACTIVATE:
        wParam = (LOWORD(wParam)==WA_ACTIVE || LOWORD(wParam)==WA_CLICKACTIVE);
        // fall through to next case
    case WM_ACTIVATEAPP:
        Application.Active = wParam != 0;
#ifndef USE_CONSOLE
        if (pGL)
        {
            if (Application.Active)
            {
                // restore textures
                if (Application.FullScreenMode())
                {
                    Application.SetVideoMode(Application.GetConfigWidth(), Application.GetConfigHeight(), Config.Graphics.RefreshRate, Config.Graphics.Monitor, true);
                }
            }
            else
            {
                if (Application.FullScreenMode())
                {
                    ::ChangeDisplaySettings(nullptr, 0);
                    ::ShowWindow(hwnd, SW_MINIMIZE);
                }
            }
        }
#endif
        // redraw background
        ::GraphicsSystem.InvalidateBg();
        // Redraw after task switch
        if (Application.Active)
            ::GraphicsSystem.Execute();
        // update cursor clip
        ::MouseControl.UpdateClip();
        return false;
    case WM_PAINT:
        // Redraw after task switch
        if (Application.Active)
            ::GraphicsSystem.Execute();
        break;
    case WM_DESTROY:
        Application.Quit();
        return 0;
    case WM_CLOSE:
        FullScreen.Close();
        return 0;
    case MM_MCINOTIFY:
        if (wParam == MCI_NOTIFY_SUCCESSFUL)
            Application.MusicSystem.NotifySuccess();
        return true;
    case WM_KEYUP:
        if (Game.DoKeyboardInput(scancode, KEYEV_Up, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, false, nullptr))
            return 0;
        break;
    case WM_KEYDOWN:
        if (Game.DoKeyboardInput(scancode, KEYEV_Down, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(lParam & 0x40000000), nullptr))
            return 0;
        break;
    case WM_SYSKEYDOWN:
        if (wParam == 18) break;
        if (Game.DoKeyboardInput(scancode, KEYEV_Down, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(lParam & 0x40000000), nullptr))
        {
            // Remove handled message from queue to prevent Windows "standard" sound for unprocessed system message
            MSG msg;
            PeekMessage(&msg, hwnd, 0, 0, PM_REMOVE);
            return 0;
        }
        break;
    case WM_CHAR:
    {
        // UTF-8 has 1 to 4 data bytes, and we need a terminating \0
        char c[5] = {0,0,0,0,0};
        if(!WideCharToMultiByte(CP_UTF8, 0L, reinterpret_cast<LPCWSTR>(&wParam), 1, c, 4, nullptr, nullptr))
            return 0;
        // GUI: forward
        if (::pGUI->CharIn(c))
            return 0;
        return false;
    }
    case WM_USER_LOG:
        if (SEqual2((const char *)lParam, "IDS_"))
            Log(LoadResStr((const char *)lParam));
        else
            Log((const char *)lParam);
        return false;
    case WM_LBUTTONDOWN:
        C4GUI::MouseMove(C4MC_Button_LeftDown,p.x,p.y,wParam, nullptr);
        break;
    case WM_LBUTTONUP: C4GUI::MouseMove(C4MC_Button_LeftUp, p.x, p.y, wParam, nullptr); break;
    case WM_RBUTTONDOWN: C4GUI::MouseMove(C4MC_Button_RightDown, p.x, p.y, wParam, nullptr); break;
    case WM_RBUTTONUP: C4GUI::MouseMove(C4MC_Button_RightUp, p.x, p.y, wParam, nullptr); break;
    case WM_LBUTTONDBLCLK: C4GUI::MouseMove(C4MC_Button_LeftDouble, p.x, p.y, wParam, nullptr); break;
    case WM_RBUTTONDBLCLK: C4GUI::MouseMove(C4MC_Button_RightDouble, p.x, p.y, wParam, nullptr); break;
    case WM_MOUSEWHEEL:
        // the coordinates are screen-coordinates here (but only on this uMsg),
        // we need to convert them to client area coordinates
        ScreenToClient(hwnd, &p);
        C4GUI::MouseMove(C4MC_Button_Wheel, p.x, p.y, wParam, nullptr);
        break;
    case WM_MOUSEMOVE:
        C4GUI::MouseMove(C4MC_Button_None, p.x, p.y, wParam, nullptr);
        // Hide cursor in client area
        if (NativeCursorShown)
        {
            NativeCursorShown = false;
            ShowCursor(FALSE);
        }
        break;
    case WM_NCMOUSEMOVE:
        // Show cursor on window frame
        if (!NativeCursorShown)
        {
            NativeCursorShown = true;
            ShowCursor(TRUE);
        }
        break;
    case WM_SIZE:
        // Notify app about render window size change
        switch (wParam)
        {
        case SIZE_RESTORED:
        case SIZE_MAXIMIZED:
            ::Application.OnResolutionChanged(p.x, p.y);
            if(Application.pWindow) // this might be called from C4Window::Init in which case Application.pWindow is not yet set
                ::SetWindowPos(Application.pWindow->renderwnd, nullptr, 0, 0, p.x, p.y, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOZORDER);
            break;
        }
        break;
    case WM_INPUTLANGCHANGE:
        ::Application.OnKeyboardLayoutChanged();
        break;
    case WM_SYSCOMMAND:
        // The user pressed Alt to open the system menu. This enters a modal
        // loop which stops us from event processing, so prevent it. Users
        // can still open the system menu by clicking the window's icon.
        if ((wParam & 0xFFF0) == SC_KEYMENU && lParam == 0)
            return 0;
        break;
    }
    return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
 
static C4KeyCode msg2scancode(MSG *msg)
{
    // compute scancode
    C4KeyCode scancode = (((unsigned int)msg->lParam) >> 16) & 0xFF;
    bool extended = ((msg->lParam & 0x01000000) != 0);
    ConvertToUnixScancode(msg->wParam, &scancode, extended);
    return scancode;
}
 
bool ConsoleHandleWin32KeyboardMessage(MSG *msg)
{
    switch (msg->message)
    {
    case WM_KEYDOWN:
        if (Game.DoKeyboardInput(msg2scancode(msg), KEYEV_Down, !!(msg->lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(msg->lParam & 0x40000000), nullptr)) return true;
        break;
    case WM_KEYUP:
        if (Game.DoKeyboardInput(msg2scancode(msg), KEYEV_Up, !!(msg->lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, false, nullptr)) return false;
        break;
    case WM_SYSKEYDOWN:
        if (msg->wParam == 18) break; // VK_MENU (Alt)
        if (Game.DoKeyboardInput(msg2scancode(msg), KEYEV_Down, !!(msg->lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(msg->lParam & 0x40000000), nullptr)) return false;
        break;
    }
    return false;
 
}
 
LRESULT APIENTRY ViewportWinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    // Determine viewport
    C4Viewport *cvp;
    if (!(cvp=::Viewports.GetViewport(hwnd)))
        return DefWindowProcW(hwnd, uMsg, wParam, lParam);
 
    // compute scancode
    C4KeyCode scancode = (((unsigned int)lParam) >> 16) & 0xFF;
    bool extended = ((lParam & 0x01000000) != 0);
    ConvertToUnixScancode(wParam, &scancode, extended);
 
    // Process message
    switch (uMsg)
    {
        //---------------------------------------------------------------------------------------------------------------------------
    case WM_KEYDOWN:
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        switch (wParam)
        {
            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        case VK_SCROLL:
            // key bound to this specific viewport. Don't want to pass this through C4Game...
            cvp->TogglePlayerLock();
            break;
            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        default:
            if (Game.DoKeyboardInput(scancode, KEYEV_Down, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(lParam & 0x40000000), nullptr)) return 0;
            break;
            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        }
        break;
        //---------------------------------------------------------------------------------------------------------------------------
    case WM_KEYUP:
        if (Game.DoKeyboardInput(scancode, KEYEV_Up, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, false, nullptr)) return 0;
        break;
        //------------------------------------------------------------------------------------------------------------
    case WM_SYSKEYDOWN:
        if (wParam == 18) break;
        if (Game.DoKeyboardInput(scancode, KEYEV_Down, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(lParam & 0x40000000), nullptr)) return 0;
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_DESTROY:
        StoreWindowPosition(hwnd, FormatString("Viewport%i",cvp->Player+1).getData(), Config.GetSubkeyPath("Console"));
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_CREATE:
        DragAcceptFiles(hwnd, TRUE);
        break;
    case WM_CLOSE:
        cvp->pWindow->Close();
        break;
 
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_DROPFILES:
    {
        HDROP hDrop = (HDROP)(HANDLE) wParam;
        if (!Console.Editing) { Console.Message(LoadResStr("IDS_CNS_NONETEDIT")); return false; }
 
        int32_t iFileNum = DragQueryFile(hDrop,0xFFFFFFFF,nullptr,0);
        POINT pntPoint;
        DragQueryPoint(hDrop,&pntPoint);
        wchar_t szFilename[500+1];
        for (int32_t cnt=0; cnt<iFileNum; cnt++)
        {
            DragQueryFileW(hDrop,cnt,szFilename,500);
            cvp->DropFile(StdStrBuf(szFilename).getData(), (float)pntPoint.x, (float)pntPoint.y);
        }
        DragFinish(hDrop);
        break;
    }
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_USER_DROPDEF:
        Game.DropDef(C4ID(lParam),cvp->GetViewX()+float(LOWORD(wParam))/cvp->Zoom,cvp->GetViewY()+float(HIWORD(wParam)/cvp->Zoom));
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_SIZE:
    case WM_SIZING:
        cvp->UpdateOutputSize();
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_PAINT:
        ::GraphicsSystem.Execute();
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_HSCROLL:
        switch (LOWORD(wParam))
        {
            case SB_THUMBTRACK:
            case SB_THUMBPOSITION: cvp->SetViewX(float(HIWORD(wParam))/cvp->Zoom); break;
            case SB_LINELEFT: cvp->ScrollView(-ViewportScrollSpeed, 0.0f); break;
            case SB_LINERIGHT: cvp->ScrollView(+ViewportScrollSpeed, 0.0f); break;
            case SB_PAGELEFT: cvp->ScrollView(-cvp->ViewWdt/cvp->Zoom, 0.0f); break;
            case SB_PAGERIGHT: cvp->ScrollView(+cvp->ViewWdt/cvp->Zoom, 0.0f); break;
        }
        cvp->Execute();
        cvp->ScrollBarsByViewPosition();
        return 0;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_VSCROLL:
        switch (LOWORD(wParam))
        {
            case SB_THUMBTRACK:
            case SB_THUMBPOSITION: cvp->SetViewY(float(HIWORD(wParam))/cvp->Zoom); break;
            case SB_LINEUP: cvp->ScrollView(0.0f,-ViewportScrollSpeed); break;
            case SB_LINEDOWN: cvp->ScrollView(0.0f,+ViewportScrollSpeed); break;
            case SB_PAGEUP: cvp->ScrollView(0.0f,-cvp->ViewWdt/cvp->Zoom); break;
            case SB_PAGEDOWN: cvp->ScrollView(0.0f,+cvp->ViewWdt/cvp->Zoom); break;
        }
        cvp->Execute();
        cvp->ScrollBarsByViewPosition();
        return 0;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_ACTIVATE:
        // Keep editing dialogs on top of the current viewport, but don't make them
        // float on other windows (i.e., no HWND_TOPMOST).
        // Also, don't use SetParent, since that activates the window, which in turn
        // posts a new WM_ACTIVATE to us, and so on, ultimately leading to a hang.
        if (LOWORD(wParam) == WA_INACTIVE)
        {
            Console.Win32KeepDialogsFloating();
        }
        else
        {
            // FALLTHROUGH
        case WM_MOUSEACTIVATE:
            // WM_MOUSEACTIVATE is emitted when the user hovers over a window and pushes a mouse button.
            // Setting the window owner here avoids z-order flickering.
            Console.Win32KeepDialogsFloating(hwnd);
        }
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_SYSCOMMAND:
        // The user pressed Alt to open the system menu. This enters a modal
        // loop which stops us from event processing, so prevent it. Users
        // can still open the system menu by clicking the window's icon.
        if ((wParam & 0xFFF0) == SC_KEYMENU && lParam == 0)
            return 0;
        break;
    }
 
    POINT p;
    p.x = GET_X_LPARAM(lParam);
    p.y = GET_Y_LPARAM(lParam);
 
    // Viewport mouse control
    if (::MouseControl.IsViewport(cvp) && (Console.EditCursor.GetMode()==C4CNS_ModePlay))
    {
        switch (uMsg)
        {
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_LBUTTONDOWN: C4GUI::MouseMove(C4MC_Button_LeftDown, p.x, p.y, wParam, cvp);  break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_LBUTTONUP: C4GUI::MouseMove(C4MC_Button_LeftUp, p.x, p.y, wParam, cvp);  break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_RBUTTONDOWN: C4GUI::MouseMove(C4MC_Button_RightDown, p.x, p.y, wParam, cvp); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_RBUTTONUP: C4GUI::MouseMove(C4MC_Button_RightUp, p.x, p.y, wParam, cvp); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_LBUTTONDBLCLK: C4GUI::MouseMove(C4MC_Button_LeftDouble, p.x, p.y, wParam, cvp);  break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_RBUTTONDBLCLK: C4GUI::MouseMove(C4MC_Button_RightDouble, p.x, p.y, wParam, cvp); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_MOUSEMOVE:
            if ( Inside<int32_t>(p.x-cvp->DrawX,0,cvp->ViewWdt-1)
                 && Inside<int32_t>(p.y-cvp->DrawY,0,cvp->ViewHgt-1) )
                SetCursor(nullptr);
            C4GUI::MouseMove(C4MC_Button_None, p.x, p.y, wParam, cvp);
            break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_MOUSEWHEEL:
            ScreenToClient(hwnd, &p);
            C4GUI::MouseMove(C4MC_Button_Wheel, p.x, p.y, wParam, cvp);
            break;
            //----------------------------------------------------------------------------------------------------------------------------------
 
        }
    }
    // Console edit cursor control
    else
    {
        // The state of the ALT key is not reported in wParam for mouse messages,
        // and for keyboard messages the key states are hidden in lParam. It's a mess. Let's just
        // query GetKeyState().
        DWORD dwKeyState = 0;
        if(GetKeyState(VK_CONTROL) < 0) dwKeyState |= MK_CONTROL;
        if(GetKeyState(VK_SHIFT) < 0) dwKeyState |= MK_SHIFT;
        if(GetKeyState(VK_MENU) < 0) dwKeyState |= MK_ALT;
 
        switch (uMsg)
        {
        case WM_KEYDOWN:
            Console.EditCursor.KeyDown(scancode, dwKeyState);
            break;
        case WM_KEYUP:
            Console.EditCursor.KeyUp(scancode, dwKeyState);
            break;
        case WM_SYSKEYDOWN:
            Console.EditCursor.KeyDown(scancode, dwKeyState);
            break;
        case WM_SYSKEYUP:
            Console.EditCursor.KeyUp(scancode, dwKeyState);
            break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_LBUTTONDOWN:
            // movement update needed before, so target is always up-to-date
            cvp->pWindow->EditCursorMove(p.x, p.y, dwKeyState);
            Console.EditCursor.LeftButtonDown(dwKeyState); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_LBUTTONUP: Console.EditCursor.LeftButtonUp(dwKeyState); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_RBUTTONDOWN: Console.EditCursor.RightButtonDown(dwKeyState); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_RBUTTONUP: Console.EditCursor.RightButtonUp(dwKeyState); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        case WM_MOUSEMOVE: cvp->pWindow->EditCursorMove(p.x, p.y, dwKeyState); break;
            //----------------------------------------------------------------------------------------------------------------------------------
        }
    }
 
    return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
 
LRESULT APIENTRY DialogWinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    // Determine dialog
    C4GUI::Dialog *pDlg = ::pGUI->GetDialog(hwnd);
    if (!pDlg) return DefWindowProc(hwnd, uMsg, wParam, lParam);
 
    POINT p;
    p.x = GET_X_LPARAM(lParam);
    p.y = GET_Y_LPARAM(lParam);
 
    // compute scancode
    C4KeyCode scancode = (((unsigned int)lParam) >> 16) & 0xFF;
    bool extended = ((lParam & 0x01000000) != 0);
    ConvertToUnixScancode(wParam, &scancode, extended);
 
    // Process message
    switch (uMsg)
    {
        //---------------------------------------------------------------------------------------------------------------------------
    case WM_KEYDOWN:
        if (Game.DoKeyboardInput(scancode, KEYEV_Down, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(lParam & 0x40000000), pDlg)) return 0;
        break;
        //---------------------------------------------------------------------------------------------------------------------------
    case WM_KEYUP:
        if (Game.DoKeyboardInput(scancode, KEYEV_Up, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, false, pDlg)) return 0;
        break;
        //------------------------------------------------------------------------------------------------------------
    case WM_SYSKEYDOWN:
        if (wParam == 18) break;
        if (Game.DoKeyboardInput(scancode, KEYEV_Down, !!(lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(lParam & 0x40000000), pDlg)) return 0;
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_DESTROY:
    {
        const char *szID = pDlg->GetID();
        if (szID && *szID)
            StoreWindowPosition(hwnd, FormatString("ConsoleGUI_%s", szID).getData(), Config.GetSubkeyPath("Console"), false);
    }
    break;
    //----------------------------------------------------------------------------------------------------------------------------------
    case WM_CLOSE:
        pDlg->Close(false);
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_SIZE:
        // UpdateOutputSize
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_PAINT:
        // 2do: only draw specific dlg?
        break;
        return 0;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_LBUTTONDOWN: ::pGUI->MouseInput(C4MC_Button_LeftDown, p.x, p.y, wParam, pDlg, nullptr); break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_LBUTTONUP: ::pGUI->MouseInput(C4MC_Button_LeftUp, p.x, p.y, wParam, pDlg, nullptr); break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_RBUTTONDOWN: ::pGUI->MouseInput(C4MC_Button_RightDown, p.x, p.y, wParam, pDlg, nullptr); break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_RBUTTONUP: ::pGUI->MouseInput(C4MC_Button_RightUp, p.x, p.y, wParam, pDlg, nullptr); break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_LBUTTONDBLCLK: ::pGUI->MouseInput(C4MC_Button_LeftDouble, p.x, p.y, wParam, pDlg, nullptr); break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_RBUTTONDBLCLK: ::pGUI->MouseInput(C4MC_Button_RightDouble, p.x, p.y, wParam, pDlg, nullptr);  break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_MOUSEMOVE:
        ::pGUI->MouseInput(C4MC_Button_None, p.x, p.y, wParam, pDlg, nullptr);
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    case WM_MOUSEWHEEL:
        ScreenToClient(hwnd, &p);
        ::pGUI->MouseInput(C4MC_Button_Wheel, p.x, p.y, wParam, pDlg, nullptr);
        break;
        //----------------------------------------------------------------------------------------------------------------------------------
    }
 
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
 
C4Window::C4Window () = default;
C4Window::~C4Window () = default;
 
C4Window * C4Window::Init(C4Window::WindowKind windowKind, C4AbstractApp * pApp, const char * Title, const C4Rect * size)
{
    Active = true;
    eKind = windowKind;
    if (windowKind == W_Viewport)
    {
#ifdef WITH_QT_EDITOR
        // embed into editor: Viewport widget creation handled by C4ConsoleQt
        ::Console.AddViewport(static_cast<C4ViewportWindow *>(this));
        return this;
#else
        static bool fViewportClassRegistered = false;
        if (!fViewportClassRegistered)
        {
            // Register viewport class
            WNDCLASSEXW WndClass;
            WndClass.cbSize=sizeof(WNDCLASSEX);
            WndClass.style         = CS_DBLCLKS | CS_BYTEALIGNCLIENT;
            WndClass.lpfnWndProc   = ViewportWinProc;
            WndClass.cbClsExtra    = 0;
            WndClass.cbWndExtra    = 0;
            WndClass.hInstance     = pApp->GetInstance();
            WndClass.hCursor       = LoadCursor (nullptr, IDC_ARROW);
            WndClass.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
            WndClass.lpszMenuName  = nullptr;
            WndClass.lpszClassName = C4ViewportClassName;
            WndClass.hIcon         = LoadIcon (pApp->GetInstance(), MAKEINTRESOURCE (IDI_01_OCS) );
            WndClass.hIconSm       = LoadIcon (pApp->GetInstance(), MAKEINTRESOURCE (IDI_01_OCS) );
            if (!RegisterClassExW(&WndClass)) return nullptr;
            fViewportClassRegistered = true;
        }
        // Create window
        hWindow = CreateWindowExW (
                    WS_EX_ACCEPTFILES,
                    C4ViewportClassName, GetWideChar(Title), C4ViewportWindowStyle,
                    CW_USEDEFAULT,CW_USEDEFAULT, size->Wdt, size->Hgt,
                    Console.hWindow,nullptr,pApp->GetInstance(),nullptr);
        if(!hWindow) return nullptr;
#endif
        // We don't re-init viewport windows currently, so we don't need a child window
        // for now: Render into main window.
        renderwnd = hWindow;
    }
    else if (windowKind == W_Fullscreen)
    {
        // Register window class
        auto WndClass = WNDCLASSEXW();
        WndClass.cbSize        = sizeof(WNDCLASSEX);
        WndClass.style         = CS_DBLCLKS;
        WndClass.lpfnWndProc   = FullScreenWinProc;
        WndClass.hInstance     = pApp->GetInstance();
        WndClass.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
        WndClass.lpszClassName = C4FullScreenClassName;
        WndClass.hIcon         = LoadIcon (pApp->GetInstance(), MAKEINTRESOURCE (IDI_00_C4X) );
        WndClass.hIconSm       = LoadIcon (pApp->GetInstance(), MAKEINTRESOURCE (IDI_00_C4X) );
        if (!RegisterClassExW(&WndClass)) return nullptr;
 
        // Create window
        hWindow = CreateWindowExW  (
                    0,
                    C4FullScreenClassName,
                    GetWideChar(Title),
                    WS_OVERLAPPEDWINDOW,
                    CW_USEDEFAULT,CW_USEDEFAULT, size->Wdt, size->Hgt,
                    nullptr,nullptr,pApp->GetInstance(),nullptr);
        if(!hWindow) return nullptr;
 
        RECT rc;
        GetClientRect(hWindow, &rc);
        renderwnd = CreateWindowExW(0, L"STATIC", nullptr, WS_CHILD,
                                        0, 0, rc.right - rc.left, rc.bottom - rc.top,
                                        hWindow, nullptr, pApp->GetInstance(), nullptr);
        if(!renderwnd) { DestroyWindow(hWindow); return nullptr; }
        ShowWindow(renderwnd, SW_SHOW);
 
    #ifndef USE_CONSOLE
        // Show & focus
        ShowWindow(hWindow,SW_SHOWNORMAL);
        SetFocus(hWindow);
    #endif
    }
    else if (windowKind == W_GuiWindow)
    {
        static bool fDialogClassRegistered = false;
        if (!fDialogClassRegistered)
        {
            // register landscape viewport class
            WNDCLASSEXW WndClass;
            WndClass.cbSize=sizeof(WNDCLASSEX);
            WndClass.style         = CS_DBLCLKS | CS_BYTEALIGNCLIENT;
            WndClass.lpfnWndProc   = DialogWinProc;
            WndClass.cbClsExtra    = 0;
            WndClass.cbWndExtra    = 0;
            WndClass.hInstance     = pApp->GetInstance();
            WndClass.hCursor       = LoadCursor (nullptr, IDC_ARROW); // - always use normal hw cursor
            WndClass.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
            WndClass.lpszMenuName  = nullptr;
            WndClass.lpszClassName = ConsoleDlgClassName;
            WndClass.hIcon         = LoadIcon (pApp->GetInstance(), MAKEINTRESOURCE (IDI_00_C4X) );
            WndClass.hIconSm       = LoadIcon (pApp->GetInstance(), MAKEINTRESOURCE (IDI_00_C4X) );
            if (!RegisterClassExW(&WndClass))
                return nullptr;
        }
        Active = true;
        // calculate required size
        RECT rtSize;
        rtSize.left = 0;
        rtSize.top = 0;
        rtSize.right = size->Wdt;
        rtSize.bottom = size->Hgt;
        if (!::AdjustWindowRectEx(&rtSize, ConsoleDlgWindowStyle, false, 0))
            return nullptr;
        // create it!
        if (!Title || !*Title) Title = "???";
        hWindow = ::CreateWindowExW(
                    0,
                    ConsoleDlgClassName, GetWideChar(Title),
                    ConsoleDlgWindowStyle,
                    CW_USEDEFAULT,CW_USEDEFAULT,rtSize.right-rtSize.left,rtSize.bottom-rtSize.top,
                    ::Console.hWindow,nullptr,pApp->GetInstance(),nullptr);
        renderwnd = hWindow;
        return hWindow ? this : nullptr;
    }
    else if (windowKind == W_Control)
    {
        // controlled externally
        hWindow = renderwnd = nullptr;
    }
    return this;
}
 
bool C4Window::ReInit(C4AbstractApp* pApp)
{
    // We don't need to change anything with the window for any
    // configuration option changes on Windows.
 
    // However, re-create the render window so that another pixel format can
    // be chosen for it. The pixel format is chosen in CStdGLCtx::Init.
 
    RECT rc;
    GetClientRect(hWindow, &rc);
    HWND hNewRenderWindow = CreateWindowExW(0, L"STATIC", nullptr, WS_CHILD,
                                            0, 0, rc.right - rc.left, rc.bottom - rc.top,
                                            hWindow, nullptr, pApp->hInstance, nullptr);
    if(!hNewRenderWindow) return false;
 
    ShowWindow(hNewRenderWindow, SW_SHOW);
    DestroyWindow(renderwnd);
    renderwnd = hNewRenderWindow;
 
    return true;
}
 
void C4Window::Clear()
{
    // Destroy window if we own it
    if (eKind != W_Control)
    {
        if (renderwnd) DestroyWindow(renderwnd);
        if (hWindow && hWindow != renderwnd) DestroyWindow(hWindow);
    }
#ifdef WITH_QT_EDITOR
    if (eKind == W_Viewport)
    {
        // embed into editor: Viewport widget creation handled by C4ConsoleQt
        ::Console.RemoveViewport(static_cast<C4ViewportWindow *>(this));
    }
#endif
    renderwnd = nullptr;
    hWindow = nullptr;
}
 
bool C4Window::StorePosition(const char *szWindowName, const char *szSubKey, bool fStoreSize)
{
    return StoreWindowPosition(hWindow, szWindowName, szSubKey, fStoreSize) != 0;
}
 
bool C4Window::RestorePosition(const char *szWindowName, const char *szSubKey, bool fHidden)
{
    if (!RestoreWindowPosition(hWindow, szWindowName, szSubKey, fHidden))
        ShowWindow(hWindow,SW_SHOWNORMAL);
    return true;
}
 
void C4Window::SetTitle(const char *szToTitle)
{
    if (hWindow) SetWindowTextW(hWindow, GetWideChar(szToTitle ? szToTitle : ""));
}
 
bool C4Window::GetSize(C4Rect * pRect)
{
    RECT r;
    if (!(hWindow && GetClientRect(hWindow,&r))) return false;
    pRect->x = r.left;
    pRect->y = r.top;
    pRect->Wdt = r.right - r.left;
    pRect->Hgt = r.bottom - r.top;
    return true;
}
 
void C4Window::SetSize(unsigned int cx, unsigned int cy)
{
    if (hWindow)
    {
        // If bordered, add border size
        RECT rect = { 0, 0, static_cast<LONG>(cx), static_cast<LONG>(cy) };
        ::AdjustWindowRectEx(&rect, GetWindowLong(hWindow, GWL_STYLE), FALSE, GetWindowLong(hWindow, GWL_EXSTYLE));
        cx = rect.right - rect.left;
        cy = rect.bottom - rect.top;
        ::SetWindowPos(hWindow, nullptr, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOZORDER);
 
        // Also resize child window
        GetClientRect(hWindow, &rect);
        ::SetWindowPos(renderwnd, nullptr, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOZORDER);
    }
}
 
void C4Window::FlashWindow()
{
    // please activate me!
    if (hWindow)
        ::FlashWindow(hWindow, FLASHW_ALL | FLASHW_TIMERNOFG);
}
 
void C4Window::GrabMouse(bool grab)
{
    // TODO
}
 
void C4Window::EnumerateMultiSamples(std::vector<int>& samples, int) const
{
#ifndef USE_CONSOLE
    if(pGL && pGL->pMainCtx)
        samples = pGL->pMainCtx->EnumerateMultiSamples();
#endif
}
 
/* CStdMessageProc */
 
bool CStdMessageProc::Execute(int iTimeout, pollfd *)
{
    // Peek messages
    MSG msg;
    while (PeekMessage(&msg,nullptr,0,0,PM_REMOVE))
    {
        // quit?
        if (msg.message == WM_QUIT)
        {
            pApp->fQuitMsgReceived = true;
            return false;
        }
        // Dialog message transfer
        if (!pApp->pWindow || !pApp->pWindow->Win32DialogMessageHandling(&msg))
        {
            TranslateMessage(&msg); DispatchMessage(&msg);
        }
    }
    return true;
}
 
/* C4AbstractApp */
 
C4AbstractApp::C4AbstractApp()
{
    ZeroMemory(&dspMode, sizeof(dspMode)); dspMode.dmSize =  sizeof(dspMode);
    ZeroMemory(&OldDspMode, sizeof(OldDspMode)); OldDspMode.dmSize =  sizeof(OldDspMode);
    idMainThread = 0;
#ifdef _WIN32
    MessageProc.SetApp(this);
    Add(&MessageProc);
#endif
}
 
C4AbstractApp::~C4AbstractApp() = default;
 
bool C4AbstractApp::Init(int argc, char * argv[])
{
    // Set instance vars
    idMainThread = ::GetCurrentThreadId();
    // Custom initialization
    return DoInit (argc, argv);
}
 
void C4AbstractApp::Clear()
{
    idMainThread = 0;
}
 
void C4AbstractApp::Quit()
{
    PostQuitMessage(0);
}
 
bool C4AbstractApp::FlushMessages()
{
 
    // Always fail after quit message
    if (fQuitMsgReceived)
        return false;
 
    return MessageProc.Execute(0);
}
 
void C4AbstractApp::SetLastErrorFromOS()
{
    LPWSTR buffer = nullptr;
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
        nullptr, ::GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPWSTR>(&buffer), 0, nullptr);
    sLastError = WStrToString(buffer);
    LocalFree(buffer);
}
 
int GLMonitorInfoEnumCount;
 
static BOOL CALLBACK GLMonitorInfoEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData)
{
    // get to indexed monitor
    if (GLMonitorInfoEnumCount--) return true;
    // store it
    C4AbstractApp *pApp = (C4AbstractApp *) dwData;
    pApp->hMon = hMonitor;
    pApp->MonitorRect = *lprcMonitor;
    return true;
}
 
bool C4AbstractApp::GetIndexedDisplayMode(int32_t iIndex, int32_t *piXRes, int32_t *piYRes, int32_t *piBitDepth, int32_t *piRefreshRate, uint32_t iMonitor)
{
    // prepare search struct
    DEVMODEW dmode;
    ZeroMemory(&dmode, sizeof(dmode)); dmode.dmSize = sizeof(dmode);
    StdStrBuf Mon;
    if (iMonitor)
        Mon.Format(R"(\\.\Display%d)", iMonitor+1);
    // check if indexed mode exists
    if (!EnumDisplaySettingsW(Mon.GetWideChar(), iIndex, &dmode))
    {
        SetLastErrorFromOS();
        return false;
    }
    // mode exists; return it
    if (piXRes) *piXRes = dmode.dmPelsWidth;
    if (piYRes) *piYRes = dmode.dmPelsHeight;
    if (piBitDepth) *piBitDepth = dmode.dmBitsPerPel;
    if (piRefreshRate) *piRefreshRate = dmode.dmDisplayFrequency;
    return true;
}
 
void C4AbstractApp::RestoreVideoMode()
{
}
 
bool C4AbstractApp::SetVideoMode(int iXRes, int iYRes, unsigned int iRefreshRate, unsigned int iMonitor, bool fFullScreen)
{
#ifndef USE_CONSOLE
    SetWindowLong(pWindow->hWindow, GWL_EXSTYLE,
                  GetWindowLong(pWindow->hWindow, GWL_EXSTYLE) | WS_EX_APPWINDOW);
    // change mode
    if (!fFullScreen)
    {
 
        ChangeDisplaySettings(nullptr, 0);
        SetWindowLong(pWindow->hWindow, GWL_STYLE,
                      GetWindowLong(pWindow->hWindow, GWL_STYLE) | (WS_CAPTION|WS_THICKFRAME|WS_BORDER));
        if(iXRes != -1 && iYRes != -1) {
            pWindow->SetSize(iXRes, iYRes);
            OnResolutionChanged(iXRes, iYRes);
        }
        ::SetWindowPos(pWindow->hWindow, nullptr, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_FRAMECHANGED);
    }
    else
    {
        bool fFound=false;
        DEVMODEW dmode;
        // if a monitor is given, search on that instead
        // get monitor infos
        GLMonitorInfoEnumCount = iMonitor;
        hMon = nullptr;
        EnumDisplayMonitors(nullptr, nullptr, GLMonitorInfoEnumProc, (LPARAM) this);
        // no monitor assigned?
        if (!hMon)
        {
            // Okay for primary; then just use a default
            if (!iMonitor)
            {
                MonitorRect.left = MonitorRect.top = 0;
                MonitorRect.right = iXRes;
                MonitorRect.bottom = iYRes;
            }
            else return false;
        }
        StdStrBuf Mon;
        if (iMonitor)
            Mon.Format(R"(\\.\Display%d)", iMonitor+1);
 
        ZeroMemory(&dmode, sizeof(dmode));
        dmode.dmSize = sizeof(dmode);
 
        // Get current display settings
        if (!EnumDisplaySettingsW(Mon.GetWideChar(), ENUM_CURRENT_SETTINGS, &dmode))
        {
            SetLastErrorFromOS();
            return false;
        }
        unsigned long orientation = dmode.dmDisplayOrientation;
        if (iXRes == -1 && iYRes == -1)
        {
            dspMode=dmode;
            fFound = true;
        }
        // enumerate modes
        int i=0;
        if (!fFound) while (EnumDisplaySettingsW(Mon.GetWideChar(), i++, &dmode))
                // compare enumerated mode with requested settings
                if (static_cast<int>(dmode.dmPelsWidth) == iXRes && static_cast<int>(dmode.dmPelsHeight) == iYRes && dmode.dmBitsPerPel == C4Draw::COLOR_DEPTH && dmode.dmDisplayOrientation == orientation
                        && (iRefreshRate == 0 || dmode.dmDisplayFrequency == iRefreshRate))
                {
                    fFound=true;
                    dspMode=dmode;
                    break;
                }
        if (!fFound) return false;
 
        dspMode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
        if (iRefreshRate != 0)
            dspMode.dmFields |= DM_DISPLAYFREQUENCY;
        LONG rv = ChangeDisplaySettingsExW(iMonitor ? Mon.GetWideChar() : nullptr, &dspMode, nullptr, CDS_FULLSCREEN, nullptr);
        if (rv != DISP_CHANGE_SUCCESSFUL)
        {
            switch (rv)
            {
#define CDSE_ERROR(error) case error: sLastError = LoadResStr("IDS_ERR_" #error); break
                CDSE_ERROR(DISP_CHANGE_BADFLAGS);
                CDSE_ERROR(DISP_CHANGE_BADMODE);
                CDSE_ERROR(DISP_CHANGE_BADPARAM);
                CDSE_ERROR(DISP_CHANGE_RESTART);
                CDSE_ERROR(DISP_CHANGE_FAILED);
#undef CDSE_ERROR
            default:
                sLastError = LoadResStr("IDS_ERR_FAILURE");
                break;
            }
            return false;
        }
 
        SetWindowLong(pWindow->hWindow, GWL_STYLE,
                      GetWindowLong(pWindow->hWindow, GWL_STYLE) & ~ (WS_CAPTION|WS_THICKFRAME|WS_BORDER));
 
        pWindow->SetSize(dspMode.dmPelsWidth, dspMode.dmPelsHeight);
        OnResolutionChanged(dspMode.dmPelsWidth, dspMode.dmPelsHeight);
        ::SetWindowPos(pWindow->hWindow, nullptr, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_FRAMECHANGED);
    }
    return true;
#endif
}
 
void C4AbstractApp::MessageDialog(const char * message)
{
    MessageBoxW(nullptr, GetWideChar(message), ADDL(C4ENGINECAPTION), MB_ICONERROR);
}
 
// Clipboard functions
bool C4AbstractApp::Copy(const std::string &text, bool fClipboard)
{
    if (!fClipboard) return false;
    bool fSuccess = true;
    // gain clipboard ownership
    if (!OpenClipboard(pWindow ? pWindow->hWindow : nullptr)) return false;
    // must empty the global clipboard, so the application clipboard equals the Windows clipboard
    EmptyClipboard();
    int size = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), text.size() + 1, nullptr, 0);
    HANDLE hglbCopy = GlobalAlloc(GMEM_MOVEABLE, size * sizeof(wchar_t));
    if (hglbCopy == nullptr) { CloseClipboard(); return false; }
    // lock the handle and copy the text to the buffer.
    wchar_t *szCopyChar = (wchar_t *) GlobalLock(hglbCopy);
    fSuccess = !!MultiByteToWideChar(CP_UTF8, 0, text.c_str(), text.size() + 1, szCopyChar, size);
    GlobalUnlock(hglbCopy);
    // place the handle on the clipboard.
    fSuccess = fSuccess && !!SetClipboardData(CF_UNICODETEXT, hglbCopy);
    // close clipboard
    CloseClipboard();
    // return whether copying was successful
    return fSuccess;
}
 
std::string C4AbstractApp::Paste(bool fClipboard)
{
    if (!fClipboard) return std::string();
    // open clipboard
    if (!OpenClipboard(nullptr)) return std::string();
    // get text from clipboard
    HANDLE hglb = GetClipboardData(CF_UNICODETEXT);
    if (!hglb) return std::string();
    std::string text{ WStrToString((wchar_t*)GlobalLock(hglb)) };
    // unlock mem
    GlobalUnlock(hglb);
    // close clipboard
    CloseClipboard();
    return text;
}
 
bool C4AbstractApp::IsClipboardFull(bool fClipboard)
{
    if (!fClipboard) return false;
    return !!IsClipboardFormatAvailable(CF_UNICODETEXT);
}
 
void C4Window::RequestUpdate()
{
    // just invoke directly
    PerformUpdate();
}