git.sesse.net Git - pistorm/blob - raylib_pi4_test/external/glfw/src/win32_init.c

   1 //========================================================================
   2 // GLFW 3.4 Win32 - www.glfw.org
   3 //------------------------------------------------------------------------
   4 // Copyright (c) 2002-2006 Marcus Geelnard
   5 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
   6 //
   7 // This software is provided 'as-is', without any express or implied
   8 // warranty. In no event will the authors be held liable for any damages
   9 // arising from the use of this software.
  10 //
  11 // Permission is granted to anyone to use this software for any purpose,
  12 // including commercial applications, and to alter it and redistribute it
  13 // freely, subject to the following restrictions:
  14 //
  15 // 1. The origin of this software must not be misrepresented; you must not
  16 //    claim that you wrote the original software. If you use this software
  17 //    in a product, an acknowledgment in the product documentation would
  18 //    be appreciated but is not required.
  19 //
  20 // 2. Altered source versions must be plainly marked as such, and must not
  21 //    be misrepresented as being the original software.
  22 //
  23 // 3. This notice may not be removed or altered from any source
  24 //    distribution.
  25 //
  26 //========================================================================
  27 // Please use C89 style variable declarations in this file because VS 2010
  28 //========================================================================
  29
  30 #include "internal.h"
  31
  32 #include <stdlib.h>
  33 #include <malloc.h>
  34
  35 static const GUID _glfw_GUID_DEVINTERFACE_HID =
  36     {0x4d1e55b2,0xf16f,0x11cf,{0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}};
  37
  38 #define GUID_DEVINTERFACE_HID _glfw_GUID_DEVINTERFACE_HID
  39
  40 #if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)
  41
  42 // Executables (but not DLLs) exporting this symbol with this value will be
  43 // automatically directed to the high-performance GPU on Nvidia Optimus systems
  44 // with up-to-date drivers
  45 //
  46 __declspec(dllexport) DWORD NvOptimusEnablement = 1;
  47
  48 // Executables (but not DLLs) exporting this symbol with this value will be
  49 // automatically directed to the high-performance GPU on AMD PowerXpress systems
  50 // with up-to-date drivers
  51 //
  52 __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
  53
  54 #endif // _GLFW_USE_HYBRID_HPG
  55
  56 #if defined(_GLFW_BUILD_DLL)
  57
  58 // GLFW DLL entry point
  59 //
  60 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
  61 {
  62     return TRUE;
  63 }
  64
  65 #endif // _GLFW_BUILD_DLL
  66
  67 // Load necessary libraries (DLLs)
  68 //
  69 static GLFWbool loadLibraries(void)
  70 {
  71     _glfw.win32.winmm.instance = LoadLibraryA("winmm.dll");
  72     if (!_glfw.win32.winmm.instance)
  73     {
  74         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
  75                              "Win32: Failed to load winmm.dll");
  76         return GLFW_FALSE;
  77     }
  78
  79     _glfw.win32.winmm.GetTime = (PFN_timeGetTime)
  80         GetProcAddress(_glfw.win32.winmm.instance, "timeGetTime");
  81
  82     _glfw.win32.user32.instance = LoadLibraryA("user32.dll");
  83     if (!_glfw.win32.user32.instance)
  84     {
  85         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
  86                              "Win32: Failed to load user32.dll");
  87         return GLFW_FALSE;
  88     }
  89
  90     _glfw.win32.user32.SetProcessDPIAware_ = (PFN_SetProcessDPIAware)
  91         GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
  92     _glfw.win32.user32.ChangeWindowMessageFilterEx_ = (PFN_ChangeWindowMessageFilterEx)
  93         GetProcAddress(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
  94     _glfw.win32.user32.EnableNonClientDpiScaling_ = (PFN_EnableNonClientDpiScaling)
  95         GetProcAddress(_glfw.win32.user32.instance, "EnableNonClientDpiScaling");
  96     _glfw.win32.user32.SetProcessDpiAwarenessContext_ = (PFN_SetProcessDpiAwarenessContext)
  97         GetProcAddress(_glfw.win32.user32.instance, "SetProcessDpiAwarenessContext");
  98     _glfw.win32.user32.GetDpiForWindow_ = (PFN_GetDpiForWindow)
  99         GetProcAddress(_glfw.win32.user32.instance, "GetDpiForWindow");
 100     _glfw.win32.user32.AdjustWindowRectExForDpi_ = (PFN_AdjustWindowRectExForDpi)
 101         GetProcAddress(_glfw.win32.user32.instance, "AdjustWindowRectExForDpi");
 102
 103     _glfw.win32.dinput8.instance = LoadLibraryA("dinput8.dll");
 104     if (_glfw.win32.dinput8.instance)
 105     {
 106         _glfw.win32.dinput8.Create = (PFN_DirectInput8Create)
 107             GetProcAddress(_glfw.win32.dinput8.instance, "DirectInput8Create");
 108     }
 109
 110     {
 111         int i;
 112         const char* names[] =
 113         {
 114             "xinput1_4.dll",
 115             "xinput1_3.dll",
 116             "xinput9_1_0.dll",
 117             "xinput1_2.dll",
 118             "xinput1_1.dll",
 119             NULL
 120         };
 121
 122         for (i = 0;  names[i];  i++)
 123         {
 124             _glfw.win32.xinput.instance = LoadLibraryA(names[i]);
 125             if (_glfw.win32.xinput.instance)
 126             {
 127                 _glfw.win32.xinput.GetCapabilities = (PFN_XInputGetCapabilities)
 128                     GetProcAddress(_glfw.win32.xinput.instance, "XInputGetCapabilities");
 129                 _glfw.win32.xinput.GetState = (PFN_XInputGetState)
 130                     GetProcAddress(_glfw.win32.xinput.instance, "XInputGetState");
 131
 132                 break;
 133             }
 134         }
 135     }
 136
 137     _glfw.win32.dwmapi.instance = LoadLibraryA("dwmapi.dll");
 138     if (_glfw.win32.dwmapi.instance)
 139     {
 140         _glfw.win32.dwmapi.IsCompositionEnabled = (PFN_DwmIsCompositionEnabled)
 141             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmIsCompositionEnabled");
 142         _glfw.win32.dwmapi.Flush = (PFN_DwmFlush)
 143             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmFlush");
 144         _glfw.win32.dwmapi.EnableBlurBehindWindow = (PFN_DwmEnableBlurBehindWindow)
 145             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmEnableBlurBehindWindow");
 146         _glfw.win32.dwmapi.GetColorizationColor = (PFN_DwmGetColorizationColor)
 147             GetProcAddress(_glfw.win32.dwmapi.instance, "DwmGetColorizationColor");
 148     }
 149
 150     _glfw.win32.shcore.instance = LoadLibraryA("shcore.dll");
 151     if (_glfw.win32.shcore.instance)
 152     {
 153         _glfw.win32.shcore.SetProcessDpiAwareness_ = (PFN_SetProcessDpiAwareness)
 154             GetProcAddress(_glfw.win32.shcore.instance, "SetProcessDpiAwareness");
 155         _glfw.win32.shcore.GetDpiForMonitor_ = (PFN_GetDpiForMonitor)
 156             GetProcAddress(_glfw.win32.shcore.instance, "GetDpiForMonitor");
 157     }
 158
 159     _glfw.win32.ntdll.instance = LoadLibraryA("ntdll.dll");
 160     if (_glfw.win32.ntdll.instance)
 161     {
 162         _glfw.win32.ntdll.RtlVerifyVersionInfo_ = (PFN_RtlVerifyVersionInfo)
 163             GetProcAddress(_glfw.win32.ntdll.instance, "RtlVerifyVersionInfo");
 164     }
 165
 166     return GLFW_TRUE;
 167 }
 168
 169 // Unload used libraries (DLLs)
 170 //
 171 static void freeLibraries(void)
 172 {
 173     if (_glfw.win32.xinput.instance)
 174         FreeLibrary(_glfw.win32.xinput.instance);
 175
 176     if (_glfw.win32.dinput8.instance)
 177         FreeLibrary(_glfw.win32.dinput8.instance);
 178
 179     if (_glfw.win32.winmm.instance)
 180         FreeLibrary(_glfw.win32.winmm.instance);
 181
 182     if (_glfw.win32.user32.instance)
 183         FreeLibrary(_glfw.win32.user32.instance);
 184
 185     if (_glfw.win32.dwmapi.instance)
 186         FreeLibrary(_glfw.win32.dwmapi.instance);
 187
 188     if (_glfw.win32.shcore.instance)
 189         FreeLibrary(_glfw.win32.shcore.instance);
 190
 191     if (_glfw.win32.ntdll.instance)
 192         FreeLibrary(_glfw.win32.ntdll.instance);
 193 }
 194
 195 // Create key code translation tables
 196 //
 197 static void createKeyTables(void)
 198 {
 199     int scancode;
 200
 201     memset(_glfw.win32.keycodes, -1, sizeof(_glfw.win32.keycodes));
 202     memset(_glfw.win32.scancodes, -1, sizeof(_glfw.win32.scancodes));
 203
 204     _glfw.win32.keycodes[0x00B] = GLFW_KEY_0;
 205     _glfw.win32.keycodes[0x002] = GLFW_KEY_1;
 206     _glfw.win32.keycodes[0x003] = GLFW_KEY_2;
 207     _glfw.win32.keycodes[0x004] = GLFW_KEY_3;
 208     _glfw.win32.keycodes[0x005] = GLFW_KEY_4;
 209     _glfw.win32.keycodes[0x006] = GLFW_KEY_5;
 210     _glfw.win32.keycodes[0x007] = GLFW_KEY_6;
 211     _glfw.win32.keycodes[0x008] = GLFW_KEY_7;
 212     _glfw.win32.keycodes[0x009] = GLFW_KEY_8;
 213     _glfw.win32.keycodes[0x00A] = GLFW_KEY_9;
 214     _glfw.win32.keycodes[0x01E] = GLFW_KEY_A;
 215     _glfw.win32.keycodes[0x030] = GLFW_KEY_B;
 216     _glfw.win32.keycodes[0x02E] = GLFW_KEY_C;
 217     _glfw.win32.keycodes[0x020] = GLFW_KEY_D;
 218     _glfw.win32.keycodes[0x012] = GLFW_KEY_E;
 219     _glfw.win32.keycodes[0x021] = GLFW_KEY_F;
 220     _glfw.win32.keycodes[0x022] = GLFW_KEY_G;
 221     _glfw.win32.keycodes[0x023] = GLFW_KEY_H;
 222     _glfw.win32.keycodes[0x017] = GLFW_KEY_I;
 223     _glfw.win32.keycodes[0x024] = GLFW_KEY_J;
 224     _glfw.win32.keycodes[0x025] = GLFW_KEY_K;
 225     _glfw.win32.keycodes[0x026] = GLFW_KEY_L;
 226     _glfw.win32.keycodes[0x032] = GLFW_KEY_M;
 227     _glfw.win32.keycodes[0x031] = GLFW_KEY_N;
 228     _glfw.win32.keycodes[0x018] = GLFW_KEY_O;
 229     _glfw.win32.keycodes[0x019] = GLFW_KEY_P;
 230     _glfw.win32.keycodes[0x010] = GLFW_KEY_Q;
 231     _glfw.win32.keycodes[0x013] = GLFW_KEY_R;
 232     _glfw.win32.keycodes[0x01F] = GLFW_KEY_S;
 233     _glfw.win32.keycodes[0x014] = GLFW_KEY_T;
 234     _glfw.win32.keycodes[0x016] = GLFW_KEY_U;
 235     _glfw.win32.keycodes[0x02F] = GLFW_KEY_V;
 236     _glfw.win32.keycodes[0x011] = GLFW_KEY_W;
 237     _glfw.win32.keycodes[0x02D] = GLFW_KEY_X;
 238     _glfw.win32.keycodes[0x015] = GLFW_KEY_Y;
 239     _glfw.win32.keycodes[0x02C] = GLFW_KEY_Z;
 240
 241     _glfw.win32.keycodes[0x028] = GLFW_KEY_APOSTROPHE;
 242     _glfw.win32.keycodes[0x02B] = GLFW_KEY_BACKSLASH;
 243     _glfw.win32.keycodes[0x033] = GLFW_KEY_COMMA;
 244     _glfw.win32.keycodes[0x00D] = GLFW_KEY_EQUAL;
 245     _glfw.win32.keycodes[0x029] = GLFW_KEY_GRAVE_ACCENT;
 246     _glfw.win32.keycodes[0x01A] = GLFW_KEY_LEFT_BRACKET;
 247     _glfw.win32.keycodes[0x00C] = GLFW_KEY_MINUS;
 248     _glfw.win32.keycodes[0x034] = GLFW_KEY_PERIOD;
 249     _glfw.win32.keycodes[0x01B] = GLFW_KEY_RIGHT_BRACKET;
 250     _glfw.win32.keycodes[0x027] = GLFW_KEY_SEMICOLON;
 251     _glfw.win32.keycodes[0x035] = GLFW_KEY_SLASH;
 252     _glfw.win32.keycodes[0x056] = GLFW_KEY_WORLD_2;
 253
 254     _glfw.win32.keycodes[0x00E] = GLFW_KEY_BACKSPACE;
 255     _glfw.win32.keycodes[0x153] = GLFW_KEY_DELETE;
 256     _glfw.win32.keycodes[0x14F] = GLFW_KEY_END;
 257     _glfw.win32.keycodes[0x01C] = GLFW_KEY_ENTER;
 258     _glfw.win32.keycodes[0x001] = GLFW_KEY_ESCAPE;
 259     _glfw.win32.keycodes[0x147] = GLFW_KEY_HOME;
 260     _glfw.win32.keycodes[0x152] = GLFW_KEY_INSERT;
 261     _glfw.win32.keycodes[0x15D] = GLFW_KEY_MENU;
 262     _glfw.win32.keycodes[0x151] = GLFW_KEY_PAGE_DOWN;
 263     _glfw.win32.keycodes[0x149] = GLFW_KEY_PAGE_UP;
 264     _glfw.win32.keycodes[0x045] = GLFW_KEY_PAUSE;
 265     _glfw.win32.keycodes[0x146] = GLFW_KEY_PAUSE;
 266     _glfw.win32.keycodes[0x039] = GLFW_KEY_SPACE;
 267     _glfw.win32.keycodes[0x00F] = GLFW_KEY_TAB;
 268     _glfw.win32.keycodes[0x03A] = GLFW_KEY_CAPS_LOCK;
 269     _glfw.win32.keycodes[0x145] = GLFW_KEY_NUM_LOCK;
 270     _glfw.win32.keycodes[0x046] = GLFW_KEY_SCROLL_LOCK;
 271     _glfw.win32.keycodes[0x03B] = GLFW_KEY_F1;
 272     _glfw.win32.keycodes[0x03C] = GLFW_KEY_F2;
 273     _glfw.win32.keycodes[0x03D] = GLFW_KEY_F3;
 274     _glfw.win32.keycodes[0x03E] = GLFW_KEY_F4;
 275     _glfw.win32.keycodes[0x03F] = GLFW_KEY_F5;
 276     _glfw.win32.keycodes[0x040] = GLFW_KEY_F6;
 277     _glfw.win32.keycodes[0x041] = GLFW_KEY_F7;
 278     _glfw.win32.keycodes[0x042] = GLFW_KEY_F8;
 279     _glfw.win32.keycodes[0x043] = GLFW_KEY_F9;
 280     _glfw.win32.keycodes[0x044] = GLFW_KEY_F10;
 281     _glfw.win32.keycodes[0x057] = GLFW_KEY_F11;
 282     _glfw.win32.keycodes[0x058] = GLFW_KEY_F12;
 283     _glfw.win32.keycodes[0x064] = GLFW_KEY_F13;
 284     _glfw.win32.keycodes[0x065] = GLFW_KEY_F14;
 285     _glfw.win32.keycodes[0x066] = GLFW_KEY_F15;
 286     _glfw.win32.keycodes[0x067] = GLFW_KEY_F16;
 287     _glfw.win32.keycodes[0x068] = GLFW_KEY_F17;
 288     _glfw.win32.keycodes[0x069] = GLFW_KEY_F18;
 289     _glfw.win32.keycodes[0x06A] = GLFW_KEY_F19;
 290     _glfw.win32.keycodes[0x06B] = GLFW_KEY_F20;
 291     _glfw.win32.keycodes[0x06C] = GLFW_KEY_F21;
 292     _glfw.win32.keycodes[0x06D] = GLFW_KEY_F22;
 293     _glfw.win32.keycodes[0x06E] = GLFW_KEY_F23;
 294     _glfw.win32.keycodes[0x076] = GLFW_KEY_F24;
 295     _glfw.win32.keycodes[0x038] = GLFW_KEY_LEFT_ALT;
 296     _glfw.win32.keycodes[0x01D] = GLFW_KEY_LEFT_CONTROL;
 297     _glfw.win32.keycodes[0x02A] = GLFW_KEY_LEFT_SHIFT;
 298     _glfw.win32.keycodes[0x15B] = GLFW_KEY_LEFT_SUPER;
 299     _glfw.win32.keycodes[0x137] = GLFW_KEY_PRINT_SCREEN;
 300     _glfw.win32.keycodes[0x138] = GLFW_KEY_RIGHT_ALT;
 301     _glfw.win32.keycodes[0x11D] = GLFW_KEY_RIGHT_CONTROL;
 302     _glfw.win32.keycodes[0x036] = GLFW_KEY_RIGHT_SHIFT;
 303     _glfw.win32.keycodes[0x15C] = GLFW_KEY_RIGHT_SUPER;
 304     _glfw.win32.keycodes[0x150] = GLFW_KEY_DOWN;
 305     _glfw.win32.keycodes[0x14B] = GLFW_KEY_LEFT;
 306     _glfw.win32.keycodes[0x14D] = GLFW_KEY_RIGHT;
 307     _glfw.win32.keycodes[0x148] = GLFW_KEY_UP;
 308
 309     _glfw.win32.keycodes[0x052] = GLFW_KEY_KP_0;
 310     _glfw.win32.keycodes[0x04F] = GLFW_KEY_KP_1;
 311     _glfw.win32.keycodes[0x050] = GLFW_KEY_KP_2;
 312     _glfw.win32.keycodes[0x051] = GLFW_KEY_KP_3;
 313     _glfw.win32.keycodes[0x04B] = GLFW_KEY_KP_4;
 314     _glfw.win32.keycodes[0x04C] = GLFW_KEY_KP_5;
 315     _glfw.win32.keycodes[0x04D] = GLFW_KEY_KP_6;
 316     _glfw.win32.keycodes[0x047] = GLFW_KEY_KP_7;
 317     _glfw.win32.keycodes[0x048] = GLFW_KEY_KP_8;
 318     _glfw.win32.keycodes[0x049] = GLFW_KEY_KP_9;
 319     _glfw.win32.keycodes[0x04E] = GLFW_KEY_KP_ADD;
 320     _glfw.win32.keycodes[0x053] = GLFW_KEY_KP_DECIMAL;
 321     _glfw.win32.keycodes[0x135] = GLFW_KEY_KP_DIVIDE;
 322     _glfw.win32.keycodes[0x11C] = GLFW_KEY_KP_ENTER;
 323     _glfw.win32.keycodes[0x059] = GLFW_KEY_KP_EQUAL;
 324     _glfw.win32.keycodes[0x037] = GLFW_KEY_KP_MULTIPLY;
 325     _glfw.win32.keycodes[0x04A] = GLFW_KEY_KP_SUBTRACT;
 326
 327     for (scancode = 0;  scancode < 512;  scancode++)
 328     {
 329         if (_glfw.win32.keycodes[scancode] > 0)
 330             _glfw.win32.scancodes[_glfw.win32.keycodes[scancode]] = scancode;
 331     }
 332 }
 333
 334 // Creates a dummy window for behind-the-scenes work
 335 //
 336 static GLFWbool createHelperWindow(void)
 337 {
 338     MSG msg;
 339
 340     _glfw.win32.helperWindowHandle =
 341         CreateWindowExW(WS_EX_OVERLAPPEDWINDOW,
 342                         _GLFW_WNDCLASSNAME,
 343                         L"GLFW message window",
 344                         WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
 345                         0, 0, 1, 1,
 346                         NULL, NULL,
 347                         GetModuleHandleW(NULL),
 348                         NULL);
 349
 350     if (!_glfw.win32.helperWindowHandle)
 351     {
 352         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
 353                              "Win32: Failed to create helper window");
 354         return GLFW_FALSE;
 355     }
 356
 357     // HACK: The command to the first ShowWindow call is ignored if the parent
 358     //       process passed along a STARTUPINFO, so clear that with a no-op call
 359     ShowWindow(_glfw.win32.helperWindowHandle, SW_HIDE);
 360
 361     // Register for HID device notifications
 362     {
 363         DEV_BROADCAST_DEVICEINTERFACE_W dbi;
 364         ZeroMemory(&dbi, sizeof(dbi));
 365         dbi.dbcc_size = sizeof(dbi);
 366         dbi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
 367         dbi.dbcc_classguid = GUID_DEVINTERFACE_HID;
 368
 369         _glfw.win32.deviceNotificationHandle =
 370             RegisterDeviceNotificationW(_glfw.win32.helperWindowHandle,
 371                                         (DEV_BROADCAST_HDR*) &dbi,
 372                                         DEVICE_NOTIFY_WINDOW_HANDLE);
 373     }
 374
 375     while (PeekMessageW(&msg, _glfw.win32.helperWindowHandle, 0, 0, PM_REMOVE))
 376     {
 377         TranslateMessage(&msg);
 378         DispatchMessageW(&msg);
 379     }
 380
 381    return GLFW_TRUE;
 382 }
 383
 384
 385 //////////////////////////////////////////////////////////////////////////
 386 //////                       GLFW internal API                      //////
 387 //////////////////////////////////////////////////////////////////////////
 388
 389 // Returns a wide string version of the specified UTF-8 string
 390 //
 391 WCHAR* _glfwCreateWideStringFromUTF8Win32(const char* source)
 392 {
 393     WCHAR* target;
 394     int count;
 395
 396     count = MultiByteToWideChar(CP_UTF8, 0, source, -1, NULL, 0);
 397     if (!count)
 398     {
 399         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
 400                              "Win32: Failed to convert string from UTF-8");
 401         return NULL;
 402     }
 403
 404     target = calloc(count, sizeof(WCHAR));
 405
 406     if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, count))
 407     {
 408         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
 409                              "Win32: Failed to convert string from UTF-8");
 410         free(target);
 411         return NULL;
 412     }
 413
 414     return target;
 415 }
 416
 417 // Returns a UTF-8 string version of the specified wide string
 418 //
 419 char* _glfwCreateUTF8FromWideStringWin32(const WCHAR* source)
 420 {
 421     char* target;
 422     int size;
 423
 424     size = WideCharToMultiByte(CP_UTF8, 0, source, -1, NULL, 0, NULL, NULL);
 425     if (!size)
 426     {
 427         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
 428                              "Win32: Failed to convert string to UTF-8");
 429         return NULL;
 430     }
 431
 432     target = calloc(size, 1);
 433
 434     if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, size, NULL, NULL))
 435     {
 436         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
 437                              "Win32: Failed to convert string to UTF-8");
 438         free(target);
 439         return NULL;
 440     }
 441
 442     return target;
 443 }
 444
 445 // Reports the specified error, appending information about the last Win32 error
 446 //
 447 void _glfwInputErrorWin32(int error, const char* description)
 448 {
 449     WCHAR buffer[_GLFW_MESSAGE_SIZE] = L"";
 450     char message[_GLFW_MESSAGE_SIZE] = "";
 451
 452     FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
 453                        FORMAT_MESSAGE_IGNORE_INSERTS |
 454                        FORMAT_MESSAGE_MAX_WIDTH_MASK,
 455                    NULL,
 456                    GetLastError() & 0xffff,
 457                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 458                    buffer,
 459                    sizeof(buffer) / sizeof(WCHAR),
 460                    NULL);
 461     WideCharToMultiByte(CP_UTF8, 0, buffer, -1, message, sizeof(message), NULL, NULL);
 462
 463     _glfwInputError(error, "%s: %s", description, message);
 464 }
 465
 466 // Updates key names according to the current keyboard layout
 467 //
 468 void _glfwUpdateKeyNamesWin32(void)
 469 {
 470     int key;
 471     BYTE state[256] = {0};
 472
 473     memset(_glfw.win32.keynames, 0, sizeof(_glfw.win32.keynames));
 474
 475     for (key = GLFW_KEY_SPACE;  key <= GLFW_KEY_LAST;  key++)
 476     {
 477         UINT vk;
 478         int scancode, length;
 479         WCHAR chars[16];
 480
 481         scancode = _glfw.win32.scancodes[key];
 482         if (scancode == -1)
 483             continue;
 484
 485         if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_ADD)
 486         {
 487             const UINT vks[] = {
 488                 VK_NUMPAD0,  VK_NUMPAD1,  VK_NUMPAD2, VK_NUMPAD3,
 489                 VK_NUMPAD4,  VK_NUMPAD5,  VK_NUMPAD6, VK_NUMPAD7,
 490                 VK_NUMPAD8,  VK_NUMPAD9,  VK_DECIMAL, VK_DIVIDE,
 491                 VK_MULTIPLY, VK_SUBTRACT, VK_ADD
 492             };
 493
 494             vk = vks[key - GLFW_KEY_KP_0];
 495         }
 496         else
 497             vk = MapVirtualKey(scancode, MAPVK_VSC_TO_VK);
 498
 499         length = ToUnicode(vk, scancode, state,
 500                            chars, sizeof(chars) / sizeof(WCHAR),
 501                            0);
 502
 503         if (length == -1)
 504         {
 505             length = ToUnicode(vk, scancode, state,
 506                                chars, sizeof(chars) / sizeof(WCHAR),
 507                                0);
 508         }
 509
 510         if (length < 1)
 511             continue;
 512
 513         WideCharToMultiByte(CP_UTF8, 0, chars, 1,
 514                             _glfw.win32.keynames[key],
 515                             sizeof(_glfw.win32.keynames[key]),
 516                             NULL, NULL);
 517     }
 518 }
 519
 520 // Replacement for IsWindowsVersionOrGreater as MinGW lacks versionhelpers.h
 521 //
 522 BOOL _glfwIsWindowsVersionOrGreaterWin32(WORD major, WORD minor, WORD sp)
 523 {
 524     OSVERSIONINFOEXW osvi = { sizeof(osvi), major, minor, 0, 0, {0}, sp };
 525     DWORD mask = VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR;
 526     ULONGLONG cond = VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL);
 527     cond = VerSetConditionMask(cond, VER_MINORVERSION, VER_GREATER_EQUAL);
 528     cond = VerSetConditionMask(cond, VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
 529     // HACK: Use RtlVerifyVersionInfo instead of VerifyVersionInfoW as the
 530     //       latter lies unless the user knew to embed a non-default manifest
 531     //       announcing support for Windows 10 via supportedOS GUID
 532     return RtlVerifyVersionInfo(&osvi, mask, cond) == 0;
 533 }
 534
 535 // Checks whether we are on at least the specified build of Windows 10
 536 //
 537 BOOL _glfwIsWindows10BuildOrGreaterWin32(WORD build)
 538 {
 539     OSVERSIONINFOEXW osvi = { sizeof(osvi), 10, 0, build };
 540     DWORD mask = VER_MAJORVERSION | VER_MINORVERSION | VER_BUILDNUMBER;
 541     ULONGLONG cond = VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL);
 542     cond = VerSetConditionMask(cond, VER_MINORVERSION, VER_GREATER_EQUAL);
 543     cond = VerSetConditionMask(cond, VER_BUILDNUMBER, VER_GREATER_EQUAL);
 544     // HACK: Use RtlVerifyVersionInfo instead of VerifyVersionInfoW as the
 545     //       latter lies unless the user knew to embed a non-default manifest
 546     //       announcing support for Windows 10 via supportedOS GUID
 547     return RtlVerifyVersionInfo(&osvi, mask, cond) == 0;
 548 }
 549
 550
 551 //////////////////////////////////////////////////////////////////////////
 552 //////                       GLFW platform API                      //////
 553 //////////////////////////////////////////////////////////////////////////
 554
 555 int _glfwPlatformInit(void)
 556 {
 557     // To make SetForegroundWindow work as we want, we need to fiddle
 558     // with the FOREGROUNDLOCKTIMEOUT system setting (we do this as early
 559     // as possible in the hope of still being the foreground process)
 560     SystemParametersInfoW(SPI_GETFOREGROUNDLOCKTIMEOUT, 0,
 561                           &_glfw.win32.foregroundLockTimeout, 0);
 562     SystemParametersInfoW(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, UIntToPtr(0),
 563                           SPIF_SENDCHANGE);
 564
 565     if (!loadLibraries())
 566         return GLFW_FALSE;
 567
 568     createKeyTables();
 569     _glfwUpdateKeyNamesWin32();
 570
 571     if (_glfwIsWindows10CreatorsUpdateOrGreaterWin32())
 572         SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
 573     else if (IsWindows8Point1OrGreater())
 574         SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
 575     else if (IsWindowsVistaOrGreater())
 576         SetProcessDPIAware();
 577
 578     if (!_glfwRegisterWindowClassWin32())
 579         return GLFW_FALSE;
 580
 581     if (!createHelperWindow())
 582         return GLFW_FALSE;
 583
 584     _glfwInitTimerWin32();
 585
 586     _glfwPollMonitorsWin32();
 587     return GLFW_TRUE;
 588 }
 589
 590 void _glfwPlatformTerminate(void)
 591 {
 592     if (_glfw.win32.deviceNotificationHandle)
 593         UnregisterDeviceNotification(_glfw.win32.deviceNotificationHandle);
 594
 595     if (_glfw.win32.helperWindowHandle)
 596         DestroyWindow(_glfw.win32.helperWindowHandle);
 597
 598     _glfwUnregisterWindowClassWin32();
 599
 600     // Restore previous foreground lock timeout system setting
 601     SystemParametersInfoW(SPI_SETFOREGROUNDLOCKTIMEOUT, 0,
 602                           UIntToPtr(_glfw.win32.foregroundLockTimeout),
 603                           SPIF_SENDCHANGE);
 604
 605     free(_glfw.win32.clipboardString);
 606     free(_glfw.win32.rawInput);
 607
 608     _glfwTerminateWGL();
 609     _glfwTerminateEGL();
 610
 611     freeLibraries();
 612 }
 613
 614 const char* _glfwPlatformGetVersionString(void)
 615 {
 616     return _GLFW_VERSION_NUMBER " Win32 WGL EGL OSMesa"
 617 #if defined(__MINGW32__)
 618         " MinGW"
 619 #elif defined(_MSC_VER)
 620         " VisualC"
 621 #endif
 622 #if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)
 623         " hybrid-GPU"
 624 #endif
 625 #if defined(_GLFW_BUILD_DLL)
 626         " DLL"
 627 #endif
 628         ;
 629 }
 630