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