imgui_impl_win32.cpp 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785
  1. // dear imgui: Platform Backend for Windows (standard windows API for 32 and 64 bits applications)
  2. // This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
  3. // Implemented features:
  4. // [X] Platform: Clipboard support (for Win32 this is actually part of core dear imgui)
  5. // [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy VK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
  6. // [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
  7. // [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
  8. // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
  9. // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
  10. // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
  11. // Read online: https://github.com/ocornut/imgui/tree/master/docs
  12. #include "imgui.h"
  13. #include "imgui_impl_win32.h"
  14. #ifndef WIN32_LEAN_AND_MEAN
  15. #define WIN32_LEAN_AND_MEAN
  16. #endif
  17. #include <windows.h>
  18. #include <tchar.h>
  19. #include <dwmapi.h>
  20. // Configuration flags to add in your imconfig.h file:
  21. //#define IMGUI_IMPL_WIN32_DISABLE_GAMEPAD // Disable gamepad support. This was meaningful before <1.81 but we now load XInput dynamically so the option is now less relevant.
  22. // Using XInput for gamepad (will load DLL dynamically)
  23. #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  24. #include <xinput.h>
  25. typedef DWORD (WINAPI *PFN_XInputGetCapabilities)(DWORD, DWORD, XINPUT_CAPABILITIES*);
  26. typedef DWORD (WINAPI *PFN_XInputGetState)(DWORD, XINPUT_STATE*);
  27. #endif
  28. // CHANGELOG
  29. // (minor and older changes stripped away, please see git history for details)
  30. // 2022-01-12: Maintain our own copy of MouseButtonsDown mask instead of using ImGui::IsAnyMouseDown() which will be obsoleted.
  31. // 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
  32. // 2021-12-16: Inputs: Fill VK_LCONTROL/VK_RCONTROL/VK_LSHIFT/VK_RSHIFT/VK_LMENU/VK_RMENU for completeness.
  33. // 2021-08-17: Calling io.AddFocusEvent() on WM_SETFOCUS/WM_KILLFOCUS messages.
  34. // 2021-08-02: Inputs: Fixed keyboard modifiers being reported when host window doesn't have focus.
  35. // 2021-07-29: Inputs: MousePos is correctly reported when the host platform window is hovered but not focused (using TrackMouseEvent() to receive WM_MOUSELEAVE events).
  36. // 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
  37. // 2021-06-08: Fixed ImGui_ImplWin32_EnableDpiAwareness() and ImGui_ImplWin32_GetDpiScaleForMonitor() to handle Windows 8.1/10 features without a manifest (per-monitor DPI, and properly calls SetProcessDpiAwareness() on 8.1).
  38. // 2021-03-23: Inputs: Clearing keyboard down array when losing focus (WM_KILLFOCUS).
  39. // 2021-02-18: Added ImGui_ImplWin32_EnableAlphaCompositing(). Non Visual Studio users will need to link with dwmapi.lib (MinGW/gcc: use -ldwmapi).
  40. // 2021-02-17: Fixed ImGui_ImplWin32_EnableDpiAwareness() attempting to get SetProcessDpiAwareness from shcore.dll on Windows 8 whereas it is only supported on Windows 8.1.
  41. // 2021-01-25: Inputs: Dynamically loading XInput DLL.
  42. // 2020-12-04: Misc: Fixed setting of io.DisplaySize to invalid/uninitialized data when after hwnd has been closed.
  43. // 2020-03-03: Inputs: Calling AddInputCharacterUTF16() to support surrogate pairs leading to codepoint >= 0x10000 (for more complete CJK inputs)
  44. // 2020-02-17: Added ImGui_ImplWin32_EnableDpiAwareness(), ImGui_ImplWin32_GetDpiScaleForHwnd(), ImGui_ImplWin32_GetDpiScaleForMonitor() helper functions.
  45. // 2020-01-14: Inputs: Added support for #define IMGUI_IMPL_WIN32_DISABLE_GAMEPAD/IMGUI_IMPL_WIN32_DISABLE_LINKING_XINPUT.
  46. // 2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor.
  47. // 2019-05-11: Inputs: Don't filter value from WM_CHAR before calling AddInputCharacter().
  48. // 2019-01-17: Misc: Using GetForegroundWindow()+IsChild() instead of GetActiveWindow() to be compatible with windows created in a different thread or parent.
  49. // 2019-01-17: Inputs: Added support for mouse buttons 4 and 5 via WM_XBUTTON* messages.
  50. // 2019-01-15: Inputs: Added support for XInput gamepads (if ImGuiConfigFlags_NavEnableGamepad is set by user application).
  51. // 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
  52. // 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
  53. // 2018-06-10: Inputs: Fixed handling of mouse wheel messages to support fine position messages (typically sent by track-pads).
  54. // 2018-06-08: Misc: Extracted imgui_impl_win32.cpp/.h away from the old combined DX9/DX10/DX11/DX12 examples.
  55. // 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors and ImGuiBackendFlags_HasSetMousePos flags + honor ImGuiConfigFlags_NoMouseCursorChange flag.
  56. // 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value and WM_SETCURSOR message handling).
  57. // 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
  58. // 2018-02-06: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
  59. // 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
  60. // 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
  61. // 2018-01-08: Inputs: Added mapping for ImGuiKey_Insert.
  62. // 2018-01-05: Inputs: Added WM_LBUTTONDBLCLK double-click handlers for window classes with the CS_DBLCLKS flag.
  63. // 2017-10-23: Inputs: Added WM_SYSKEYDOWN / WM_SYSKEYUP handlers so e.g. the VK_MENU key can be read.
  64. // 2017-10-23: Inputs: Using Win32 ::SetCapture/::GetCapture() to retrieve mouse positions outside the client area when dragging.
  65. // 2016-11-12: Inputs: Only call Win32 ::SetCursor(NULL) when io.MouseDrawCursor is set.
  66. struct ImGui_ImplWin32_Data
  67. {
  68. HWND hWnd;
  69. HWND MouseHwnd;
  70. bool MouseTracked;
  71. int MouseButtonsDown;
  72. INT64 Time;
  73. INT64 TicksPerSecond;
  74. ImGuiMouseCursor LastMouseCursor;
  75. bool HasGamepad;
  76. bool WantUpdateHasGamepad;
  77. #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  78. HMODULE XInputDLL;
  79. PFN_XInputGetCapabilities XInputGetCapabilities;
  80. PFN_XInputGetState XInputGetState;
  81. #endif
  82. ImGui_ImplWin32_Data() { memset(this, 0, sizeof(*this)); }
  83. };
  84. // Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
  85. // It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
  86. // FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
  87. // FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
  88. static ImGui_ImplWin32_Data* ImGui_ImplWin32_GetBackendData()
  89. {
  90. return ImGui::GetCurrentContext() ? (ImGui_ImplWin32_Data*)ImGui::GetIO().BackendPlatformUserData : NULL;
  91. }
  92. // Functions
  93. bool ImGui_ImplWin32_Init(void* hwnd)
  94. {
  95. ImGuiIO& io = ImGui::GetIO();
  96. IM_ASSERT(io.BackendPlatformUserData == NULL && "Already initialized a platform backend!");
  97. INT64 perf_frequency, perf_counter;
  98. if (!::QueryPerformanceFrequency((LARGE_INTEGER*)&perf_frequency))
  99. return false;
  100. if (!::QueryPerformanceCounter((LARGE_INTEGER*)&perf_counter))
  101. return false;
  102. // Setup backend capabilities flags
  103. ImGui_ImplWin32_Data* bd = IM_NEW(ImGui_ImplWin32_Data)();
  104. io.BackendPlatformUserData = (void*)bd;
  105. io.BackendPlatformName = "imgui_impl_win32";
  106. io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
  107. io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
  108. bd->hWnd = (HWND)hwnd;
  109. bd->WantUpdateHasGamepad = true;
  110. bd->TicksPerSecond = perf_frequency;
  111. bd->Time = perf_counter;
  112. bd->LastMouseCursor = ImGuiMouseCursor_COUNT;
  113. // Set platform dependent data in viewport
  114. ImGui::GetMainViewport()->PlatformHandleRaw = (void*)hwnd;
  115. // Dynamically load XInput library
  116. #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  117. const char* xinput_dll_names[] =
  118. {
  119. "xinput1_4.dll", // Windows 8+
  120. "xinput1_3.dll", // DirectX SDK
  121. "xinput9_1_0.dll", // Windows Vista, Windows 7
  122. "xinput1_2.dll", // DirectX SDK
  123. "xinput1_1.dll" // DirectX SDK
  124. };
  125. for (int n = 0; n < IM_ARRAYSIZE(xinput_dll_names); n++)
  126. if (HMODULE dll = ::LoadLibraryA(xinput_dll_names[n]))
  127. {
  128. bd->XInputDLL = dll;
  129. bd->XInputGetCapabilities = (PFN_XInputGetCapabilities)::GetProcAddress(dll, "XInputGetCapabilities");
  130. bd->XInputGetState = (PFN_XInputGetState)::GetProcAddress(dll, "XInputGetState");
  131. break;
  132. }
  133. #endif // IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  134. return true;
  135. }
  136. void ImGui_ImplWin32_Shutdown()
  137. {
  138. ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
  139. IM_ASSERT(bd != NULL && "No platform backend to shutdown, or already shutdown?");
  140. ImGuiIO& io = ImGui::GetIO();
  141. // Unload XInput library
  142. #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  143. if (bd->XInputDLL)
  144. ::FreeLibrary(bd->XInputDLL);
  145. #endif // IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  146. io.BackendPlatformName = NULL;
  147. io.BackendPlatformUserData = NULL;
  148. IM_DELETE(bd);
  149. }
  150. static bool ImGui_ImplWin32_UpdateMouseCursor()
  151. {
  152. ImGuiIO& io = ImGui::GetIO();
  153. if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
  154. return false;
  155. ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
  156. if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
  157. {
  158. // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
  159. ::SetCursor(NULL);
  160. }
  161. else
  162. {
  163. // Show OS mouse cursor
  164. LPTSTR win32_cursor = IDC_ARROW;
  165. switch (imgui_cursor)
  166. {
  167. case ImGuiMouseCursor_Arrow: win32_cursor = IDC_ARROW; break;
  168. case ImGuiMouseCursor_TextInput: win32_cursor = IDC_IBEAM; break;
  169. case ImGuiMouseCursor_ResizeAll: win32_cursor = IDC_SIZEALL; break;
  170. case ImGuiMouseCursor_ResizeEW: win32_cursor = IDC_SIZEWE; break;
  171. case ImGuiMouseCursor_ResizeNS: win32_cursor = IDC_SIZENS; break;
  172. case ImGuiMouseCursor_ResizeNESW: win32_cursor = IDC_SIZENESW; break;
  173. case ImGuiMouseCursor_ResizeNWSE: win32_cursor = IDC_SIZENWSE; break;
  174. case ImGuiMouseCursor_Hand: win32_cursor = IDC_HAND; break;
  175. case ImGuiMouseCursor_NotAllowed: win32_cursor = IDC_NO; break;
  176. }
  177. ::SetCursor(::LoadCursor(NULL, win32_cursor));
  178. }
  179. return true;
  180. }
  181. static bool IsVkDown(int vk)
  182. {
  183. return (::GetKeyState(vk) & 0x8000) != 0;
  184. }
  185. static void ImGui_ImplWin32_AddKeyEvent(ImGuiKey key, bool down, int native_keycode, int native_scancode = -1)
  186. {
  187. ImGuiIO& io = ImGui::GetIO();
  188. io.AddKeyEvent(key, down);
  189. io.SetKeyEventNativeData(key, native_keycode, native_scancode); // To support legacy indexing (<1.87 user code)
  190. IM_UNUSED(native_scancode);
  191. }
  192. static void ImGui_ImplWin32_ProcessKeyEventsWorkarounds()
  193. {
  194. // Left & right Shift keys: when both are pressed together, Windows tend to not generate the WM_KEYUP event for the first released one.
  195. if (ImGui::IsKeyDown(ImGuiKey_LeftShift) && !IsVkDown(VK_LSHIFT))
  196. ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftShift, false, VK_LSHIFT);
  197. if (ImGui::IsKeyDown(ImGuiKey_RightShift) && !IsVkDown(VK_RSHIFT))
  198. ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightShift, false, VK_RSHIFT);
  199. // Sometimes WM_KEYUP for Win key is not passed down to the app (e.g. for Win+V on some setups, according to GLFW).
  200. if (ImGui::IsKeyDown(ImGuiKey_LeftSuper) && !IsVkDown(VK_LWIN))
  201. ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftSuper, false, VK_LWIN);
  202. if (ImGui::IsKeyDown(ImGuiKey_RightSuper) && !IsVkDown(VK_RWIN))
  203. ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightSuper, false, VK_RWIN);
  204. }
  205. static void ImGui_ImplWin32_UpdateKeyModifiers()
  206. {
  207. ImGuiIO& io = ImGui::GetIO();
  208. ImGuiKeyModFlags key_mods =
  209. ((IsVkDown(VK_LCONTROL) || IsVkDown(VK_RCONTROL)) ? ImGuiKeyModFlags_Ctrl : 0) |
  210. ((IsVkDown(VK_LSHIFT) || IsVkDown(VK_RSHIFT)) ? ImGuiKeyModFlags_Shift : 0) |
  211. ((IsVkDown(VK_LMENU) || IsVkDown(VK_RMENU)) ? ImGuiKeyModFlags_Alt : 0) |
  212. ((IsVkDown(VK_LWIN) || IsVkDown(VK_RWIN)) ? ImGuiKeyModFlags_Super : 0);
  213. io.AddKeyModsEvent(key_mods);
  214. }
  215. static void ImGui_ImplWin32_UpdateMousePos()
  216. {
  217. ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
  218. ImGuiIO& io = ImGui::GetIO();
  219. IM_ASSERT(bd->hWnd != 0);
  220. const ImVec2 mouse_pos_prev = io.MousePos;
  221. io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
  222. // Obtain focused and hovered window. We forward mouse input when focused or when hovered (and no other window is capturing)
  223. HWND focused_window = ::GetForegroundWindow();
  224. HWND hovered_window = bd->MouseHwnd;
  225. HWND mouse_window = NULL;
  226. if (hovered_window && (hovered_window == bd->hWnd || ::IsChild(hovered_window, bd->hWnd)))
  227. mouse_window = hovered_window;
  228. else if (focused_window && (focused_window == bd->hWnd || ::IsChild(focused_window, bd->hWnd)))
  229. mouse_window = focused_window;
  230. if (mouse_window == NULL)
  231. return;
  232. // Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
  233. if (io.WantSetMousePos)
  234. {
  235. POINT pos = { (int)mouse_pos_prev.x, (int)mouse_pos_prev.y };
  236. if (::ClientToScreen(bd->hWnd, &pos))
  237. ::SetCursorPos(pos.x, pos.y);
  238. }
  239. // Set Dear ImGui mouse position from OS position
  240. POINT pos;
  241. if (::GetCursorPos(&pos) && ::ScreenToClient(mouse_window, &pos))
  242. io.MousePos = ImVec2((float)pos.x, (float)pos.y);
  243. }
  244. // Gamepad navigation mapping
  245. static void ImGui_ImplWin32_UpdateGamepads()
  246. {
  247. #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  248. ImGuiIO& io = ImGui::GetIO();
  249. ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
  250. memset(io.NavInputs, 0, sizeof(io.NavInputs));
  251. if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
  252. return;
  253. // Calling XInputGetState() every frame on disconnected gamepads is unfortunately too slow.
  254. // Instead we refresh gamepad availability by calling XInputGetCapabilities() _only_ after receiving WM_DEVICECHANGE.
  255. if (bd->WantUpdateHasGamepad)
  256. {
  257. XINPUT_CAPABILITIES caps;
  258. bd->HasGamepad = bd->XInputGetCapabilities ? (bd->XInputGetCapabilities(0, XINPUT_FLAG_GAMEPAD, &caps) == ERROR_SUCCESS) : false;
  259. bd->WantUpdateHasGamepad = false;
  260. }
  261. io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
  262. XINPUT_STATE xinput_state;
  263. if (bd->HasGamepad && bd->XInputGetState && bd->XInputGetState(0, &xinput_state) == ERROR_SUCCESS)
  264. {
  265. const XINPUT_GAMEPAD& gamepad = xinput_state.Gamepad;
  266. io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
  267. #define MAP_BUTTON(NAV_NO, BUTTON_ENUM) { io.NavInputs[NAV_NO] = (gamepad.wButtons & BUTTON_ENUM) ? 1.0f : 0.0f; }
  268. #define MAP_ANALOG(NAV_NO, VALUE, V0, V1) { float vn = (float)(VALUE - V0) / (float)(V1 - V0); if (vn > 1.0f) vn = 1.0f; if (vn > 0.0f && io.NavInputs[NAV_NO] < vn) io.NavInputs[NAV_NO] = vn; }
  269. MAP_BUTTON(ImGuiNavInput_Activate, XINPUT_GAMEPAD_A); // Cross / A
  270. MAP_BUTTON(ImGuiNavInput_Cancel, XINPUT_GAMEPAD_B); // Circle / B
  271. MAP_BUTTON(ImGuiNavInput_Menu, XINPUT_GAMEPAD_X); // Square / X
  272. MAP_BUTTON(ImGuiNavInput_Input, XINPUT_GAMEPAD_Y); // Triangle / Y
  273. MAP_BUTTON(ImGuiNavInput_DpadLeft, XINPUT_GAMEPAD_DPAD_LEFT); // D-Pad Left
  274. MAP_BUTTON(ImGuiNavInput_DpadRight, XINPUT_GAMEPAD_DPAD_RIGHT); // D-Pad Right
  275. MAP_BUTTON(ImGuiNavInput_DpadUp, XINPUT_GAMEPAD_DPAD_UP); // D-Pad Up
  276. MAP_BUTTON(ImGuiNavInput_DpadDown, XINPUT_GAMEPAD_DPAD_DOWN); // D-Pad Down
  277. MAP_BUTTON(ImGuiNavInput_FocusPrev, XINPUT_GAMEPAD_LEFT_SHOULDER); // L1 / LB
  278. MAP_BUTTON(ImGuiNavInput_FocusNext, XINPUT_GAMEPAD_RIGHT_SHOULDER); // R1 / RB
  279. MAP_BUTTON(ImGuiNavInput_TweakSlow, XINPUT_GAMEPAD_LEFT_SHOULDER); // L1 / LB
  280. MAP_BUTTON(ImGuiNavInput_TweakFast, XINPUT_GAMEPAD_RIGHT_SHOULDER); // R1 / RB
  281. MAP_ANALOG(ImGuiNavInput_LStickLeft, gamepad.sThumbLX, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32768);
  282. MAP_ANALOG(ImGuiNavInput_LStickRight, gamepad.sThumbLX, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767);
  283. MAP_ANALOG(ImGuiNavInput_LStickUp, gamepad.sThumbLY, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767);
  284. MAP_ANALOG(ImGuiNavInput_LStickDown, gamepad.sThumbLY, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32767);
  285. #undef MAP_BUTTON
  286. #undef MAP_ANALOG
  287. }
  288. #endif // #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
  289. }
  290. void ImGui_ImplWin32_NewFrame()
  291. {
  292. ImGuiIO& io = ImGui::GetIO();
  293. ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
  294. IM_ASSERT(bd != NULL && "Did you call ImGui_ImplWin32_Init()?");
  295. // Setup display size (every frame to accommodate for window resizing)
  296. RECT rect = { 0, 0, 0, 0 };
  297. ::GetClientRect(bd->hWnd, &rect);
  298. io.DisplaySize = ImVec2((float)(rect.right - rect.left), (float)(rect.bottom - rect.top));
  299. // Setup time step
  300. INT64 current_time = 0;
  301. ::QueryPerformanceCounter((LARGE_INTEGER*)&current_time);
  302. io.DeltaTime = (float)(current_time - bd->Time) / bd->TicksPerSecond;
  303. bd->Time = current_time;
  304. // Process workarounds for known Windows key handling issues
  305. ImGui_ImplWin32_ProcessKeyEventsWorkarounds();
  306. // Update key modifiers
  307. ImGui_ImplWin32_UpdateKeyModifiers();
  308. // Update OS mouse position
  309. ImGui_ImplWin32_UpdateMousePos();
  310. // Update OS mouse cursor with the cursor requested by imgui
  311. ImGuiMouseCursor mouse_cursor = io.MouseDrawCursor ? ImGuiMouseCursor_None : ImGui::GetMouseCursor();
  312. if (bd->LastMouseCursor != mouse_cursor)
  313. {
  314. bd->LastMouseCursor = mouse_cursor;
  315. ImGui_ImplWin32_UpdateMouseCursor();
  316. }
  317. // Update game controllers (if enabled and available)
  318. ImGui_ImplWin32_UpdateGamepads();
  319. }
  320. // There is no distinct VK_xxx for keypad enter, instead it is VK_RETURN + KF_EXTENDED, we assign it an arbitrary value to make code more readable (VK_ codes go up to 255)
  321. #define IM_VK_KEYPAD_ENTER (VK_RETURN + 256)
  322. // Map VK_xxx to ImGuiKey_xxx.
  323. static ImGuiKey ImGui_ImplWin32_VirtualKeyToImGuiKey(WPARAM wParam)
  324. {
  325. switch (wParam)
  326. {
  327. case VK_TAB: return ImGuiKey_Tab;
  328. case VK_LEFT: return ImGuiKey_LeftArrow;
  329. case VK_RIGHT: return ImGuiKey_RightArrow;
  330. case VK_UP: return ImGuiKey_UpArrow;
  331. case VK_DOWN: return ImGuiKey_DownArrow;
  332. case VK_PRIOR: return ImGuiKey_PageUp;
  333. case VK_NEXT: return ImGuiKey_PageDown;
  334. case VK_HOME: return ImGuiKey_Home;
  335. case VK_END: return ImGuiKey_End;
  336. case VK_INSERT: return ImGuiKey_Insert;
  337. case VK_DELETE: return ImGuiKey_Delete;
  338. case VK_BACK: return ImGuiKey_Backspace;
  339. case VK_SPACE: return ImGuiKey_Space;
  340. case VK_RETURN: return ImGuiKey_Enter;
  341. case VK_ESCAPE: return ImGuiKey_Escape;
  342. case VK_OEM_7: return ImGuiKey_Apostrophe;
  343. case VK_OEM_COMMA: return ImGuiKey_Comma;
  344. case VK_OEM_MINUS: return ImGuiKey_Minus;
  345. case VK_OEM_PERIOD: return ImGuiKey_Period;
  346. case VK_OEM_2: return ImGuiKey_Slash;
  347. case VK_OEM_1: return ImGuiKey_Semicolon;
  348. case VK_OEM_PLUS: return ImGuiKey_Equal;
  349. case VK_OEM_4: return ImGuiKey_LeftBracket;
  350. case VK_OEM_5: return ImGuiKey_Backslash;
  351. case VK_OEM_6: return ImGuiKey_RightBracket;
  352. case VK_OEM_3: return ImGuiKey_GraveAccent;
  353. case VK_CAPITAL: return ImGuiKey_CapsLock;
  354. case VK_SCROLL: return ImGuiKey_ScrollLock;
  355. case VK_NUMLOCK: return ImGuiKey_NumLock;
  356. case VK_SNAPSHOT: return ImGuiKey_PrintScreen;
  357. case VK_PAUSE: return ImGuiKey_Pause;
  358. case VK_NUMPAD0: return ImGuiKey_Keypad0;
  359. case VK_NUMPAD1: return ImGuiKey_Keypad1;
  360. case VK_NUMPAD2: return ImGuiKey_Keypad2;
  361. case VK_NUMPAD3: return ImGuiKey_Keypad3;
  362. case VK_NUMPAD4: return ImGuiKey_Keypad4;
  363. case VK_NUMPAD5: return ImGuiKey_Keypad5;
  364. case VK_NUMPAD6: return ImGuiKey_Keypad6;
  365. case VK_NUMPAD7: return ImGuiKey_Keypad7;
  366. case VK_NUMPAD8: return ImGuiKey_Keypad8;
  367. case VK_NUMPAD9: return ImGuiKey_Keypad9;
  368. case VK_DECIMAL: return ImGuiKey_KeypadDecimal;
  369. case VK_DIVIDE: return ImGuiKey_KeypadDivide;
  370. case VK_MULTIPLY: return ImGuiKey_KeypadMultiply;
  371. case VK_SUBTRACT: return ImGuiKey_KeypadSubtract;
  372. case VK_ADD: return ImGuiKey_KeypadAdd;
  373. case IM_VK_KEYPAD_ENTER: return ImGuiKey_KeypadEnter;
  374. case VK_LSHIFT: return ImGuiKey_LeftShift;
  375. case VK_LCONTROL: return ImGuiKey_LeftControl;
  376. case VK_LMENU: return ImGuiKey_LeftAlt;
  377. case VK_LWIN: return ImGuiKey_LeftSuper;
  378. case VK_RSHIFT: return ImGuiKey_RightShift;
  379. case VK_RCONTROL: return ImGuiKey_RightControl;
  380. case VK_RMENU: return ImGuiKey_RightAlt;
  381. case VK_RWIN: return ImGuiKey_RightSuper;
  382. case VK_APPS: return ImGuiKey_Menu;
  383. case '0': return ImGuiKey_0;
  384. case '1': return ImGuiKey_1;
  385. case '2': return ImGuiKey_2;
  386. case '3': return ImGuiKey_3;
  387. case '4': return ImGuiKey_4;
  388. case '5': return ImGuiKey_5;
  389. case '6': return ImGuiKey_6;
  390. case '7': return ImGuiKey_7;
  391. case '8': return ImGuiKey_8;
  392. case '9': return ImGuiKey_9;
  393. case 'A': return ImGuiKey_A;
  394. case 'B': return ImGuiKey_B;
  395. case 'C': return ImGuiKey_C;
  396. case 'D': return ImGuiKey_D;
  397. case 'E': return ImGuiKey_E;
  398. case 'F': return ImGuiKey_F;
  399. case 'G': return ImGuiKey_G;
  400. case 'H': return ImGuiKey_H;
  401. case 'I': return ImGuiKey_I;
  402. case 'J': return ImGuiKey_J;
  403. case 'K': return ImGuiKey_K;
  404. case 'L': return ImGuiKey_L;
  405. case 'M': return ImGuiKey_M;
  406. case 'N': return ImGuiKey_N;
  407. case 'O': return ImGuiKey_O;
  408. case 'P': return ImGuiKey_P;
  409. case 'Q': return ImGuiKey_Q;
  410. case 'R': return ImGuiKey_R;
  411. case 'S': return ImGuiKey_S;
  412. case 'T': return ImGuiKey_T;
  413. case 'U': return ImGuiKey_U;
  414. case 'V': return ImGuiKey_V;
  415. case 'W': return ImGuiKey_W;
  416. case 'X': return ImGuiKey_X;
  417. case 'Y': return ImGuiKey_Y;
  418. case 'Z': return ImGuiKey_Z;
  419. case VK_F1: return ImGuiKey_F1;
  420. case VK_F2: return ImGuiKey_F2;
  421. case VK_F3: return ImGuiKey_F3;
  422. case VK_F4: return ImGuiKey_F4;
  423. case VK_F5: return ImGuiKey_F5;
  424. case VK_F6: return ImGuiKey_F6;
  425. case VK_F7: return ImGuiKey_F7;
  426. case VK_F8: return ImGuiKey_F8;
  427. case VK_F9: return ImGuiKey_F9;
  428. case VK_F10: return ImGuiKey_F10;
  429. case VK_F11: return ImGuiKey_F11;
  430. case VK_F12: return ImGuiKey_F12;
  431. default: return ImGuiKey_None;
  432. }
  433. }
  434. // Allow compilation with old Windows SDK. MinGW doesn't have default _WIN32_WINNT/WINVER versions.
  435. #ifndef WM_MOUSEHWHEEL
  436. #define WM_MOUSEHWHEEL 0x020E
  437. #endif
  438. #ifndef DBT_DEVNODES_CHANGED
  439. #define DBT_DEVNODES_CHANGED 0x0007
  440. #endif
  441. // Win32 message handler (process Win32 mouse/keyboard inputs, etc.)
  442. // Call from your application's message handler.
  443. // When implementing your own backend, you can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if Dear ImGui wants to use your inputs.
  444. // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
  445. // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
  446. // Generally you may always pass all inputs to Dear ImGui, and hide them from your application based on those two flags.
  447. // PS: In this Win32 handler, we use the capture API (GetCapture/SetCapture/ReleaseCapture) to be able to read mouse coordinates when dragging mouse outside of our window bounds.
  448. // PS: We treat DBLCLK messages as regular mouse down messages, so this code will work on windows classes that have the CS_DBLCLKS flag set. Our own example app code doesn't set this flag.
  449. #if 0
  450. // Copy this line into your .cpp file to forward declare the function.
  451. extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
  452. #endif
  453. IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  454. {
  455. if (ImGui::GetCurrentContext() == NULL)
  456. return 0;
  457. ImGuiIO& io = ImGui::GetIO();
  458. ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
  459. switch (msg)
  460. {
  461. case WM_MOUSEMOVE:
  462. // We need to call TrackMouseEvent in order to receive WM_MOUSELEAVE events
  463. bd->MouseHwnd = hwnd;
  464. if (!bd->MouseTracked)
  465. {
  466. TRACKMOUSEEVENT tme = { sizeof(tme), TME_LEAVE, hwnd, 0 };
  467. ::TrackMouseEvent(&tme);
  468. bd->MouseTracked = true;
  469. }
  470. break;
  471. case WM_MOUSELEAVE:
  472. if (bd->MouseHwnd == hwnd)
  473. bd->MouseHwnd = NULL;
  474. bd->MouseTracked = false;
  475. break;
  476. case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK:
  477. case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK:
  478. case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK:
  479. case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK:
  480. {
  481. int button = 0;
  482. if (msg == WM_LBUTTONDOWN || msg == WM_LBUTTONDBLCLK) { button = 0; }
  483. if (msg == WM_RBUTTONDOWN || msg == WM_RBUTTONDBLCLK) { button = 1; }
  484. if (msg == WM_MBUTTONDOWN || msg == WM_MBUTTONDBLCLK) { button = 2; }
  485. if (msg == WM_XBUTTONDOWN || msg == WM_XBUTTONDBLCLK) { button = (GET_XBUTTON_WPARAM(wParam) == XBUTTON1) ? 3 : 4; }
  486. if (bd->MouseButtonsDown == 0 && ::GetCapture() == NULL)
  487. ::SetCapture(hwnd);
  488. io.MouseDown[button] = true;
  489. bd->MouseButtonsDown |= 1 << button;
  490. return 0;
  491. }
  492. case WM_LBUTTONUP:
  493. case WM_RBUTTONUP:
  494. case WM_MBUTTONUP:
  495. case WM_XBUTTONUP:
  496. {
  497. int button = 0;
  498. if (msg == WM_LBUTTONUP) { button = 0; }
  499. if (msg == WM_RBUTTONUP) { button = 1; }
  500. if (msg == WM_MBUTTONUP) { button = 2; }
  501. if (msg == WM_XBUTTONUP) { button = (GET_XBUTTON_WPARAM(wParam) == XBUTTON1) ? 3 : 4; }
  502. io.MouseDown[button] = false;
  503. bd->MouseButtonsDown &= ~(1 << button);
  504. if (bd->MouseButtonsDown == 0 && ::GetCapture() == hwnd)
  505. ::ReleaseCapture();
  506. return 0;
  507. }
  508. case WM_MOUSEWHEEL:
  509. io.MouseWheel += (float)GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA;
  510. return 0;
  511. case WM_MOUSEHWHEEL:
  512. io.MouseWheelH += (float)GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA;
  513. return 0;
  514. case WM_KEYDOWN:
  515. case WM_KEYUP:
  516. case WM_SYSKEYDOWN:
  517. case WM_SYSKEYUP:
  518. {
  519. const bool is_key_down = (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN);
  520. if (wParam < 256)
  521. {
  522. // Obtain virtual key code
  523. // (keypad enter doesn't have its own... VK_RETURN with KF_EXTENDED flag means keypad enter, see IM_VK_KEYPAD_ENTER definition for details, it is mapped to ImGuiKey_KeyPadEnter.)
  524. int vk = (int)wParam;
  525. if ((wParam == VK_RETURN) && (HIWORD(lParam) & KF_EXTENDED))
  526. vk = IM_VK_KEYPAD_ENTER;
  527. // Submit key event
  528. const ImGuiKey key = ImGui_ImplWin32_VirtualKeyToImGuiKey(vk);
  529. const int scancode = (int)LOBYTE(HIWORD(lParam));
  530. if (key != ImGuiKey_None)
  531. ImGui_ImplWin32_AddKeyEvent(key, is_key_down, vk, scancode);
  532. // Submit individual left/right modifier events
  533. if (vk == VK_SHIFT)
  534. {
  535. // Important: Shift keys tend to get stuck when pressed together, missing key-up events are corrected in ImGui_ImplWin32_ProcessKeyEventsWorkarounds()
  536. if (IsVkDown(VK_LSHIFT) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftShift, is_key_down, VK_LSHIFT, scancode); }
  537. if (IsVkDown(VK_RSHIFT) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightShift, is_key_down, VK_RSHIFT, scancode); }
  538. }
  539. else if (vk == VK_CONTROL)
  540. {
  541. if (IsVkDown(VK_LCONTROL) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftControl, is_key_down, VK_LCONTROL, scancode); }
  542. if (IsVkDown(VK_RCONTROL) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightControl, is_key_down, VK_RCONTROL, scancode); }
  543. }
  544. else if (vk == VK_MENU)
  545. {
  546. if (IsVkDown(VK_LMENU) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftAlt, is_key_down, VK_LMENU, scancode); }
  547. if (IsVkDown(VK_RMENU) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightAlt, is_key_down, VK_RMENU, scancode); }
  548. }
  549. }
  550. return 0;
  551. }
  552. case WM_SETFOCUS:
  553. case WM_KILLFOCUS:
  554. io.AddFocusEvent(msg == WM_SETFOCUS);
  555. return 0;
  556. case WM_CHAR:
  557. // You can also use ToAscii()+GetKeyboardState() to retrieve characters.
  558. if (wParam > 0 && wParam < 0x10000)
  559. io.AddInputCharacterUTF16((unsigned short)wParam);
  560. return 0;
  561. case WM_SETCURSOR:
  562. if (LOWORD(lParam) == HTCLIENT && ImGui_ImplWin32_UpdateMouseCursor())
  563. return 1;
  564. return 0;
  565. case WM_DEVICECHANGE:
  566. if ((UINT)wParam == DBT_DEVNODES_CHANGED)
  567. bd->WantUpdateHasGamepad = true;
  568. return 0;
  569. }
  570. return 0;
  571. }
  572. //--------------------------------------------------------------------------------------------------------
  573. // DPI-related helpers (optional)
  574. //--------------------------------------------------------------------------------------------------------
  575. // - Use to enable DPI awareness without having to create an application manifest.
  576. // - Your own app may already do this via a manifest or explicit calls. This is mostly useful for our examples/ apps.
  577. // - In theory we could call simple functions from Windows SDK such as SetProcessDPIAware(), SetProcessDpiAwareness(), etc.
  578. // but most of the functions provided by Microsoft require Windows 8.1/10+ SDK at compile time and Windows 8/10+ at runtime,
  579. // neither we want to require the user to have. So we dynamically select and load those functions to avoid dependencies.
  580. //---------------------------------------------------------------------------------------------------------
  581. // This is the scheme successfully used by GLFW (from which we borrowed some of the code) and other apps aiming to be highly portable.
  582. // ImGui_ImplWin32_EnableDpiAwareness() is just a helper called by main.cpp, we don't call it automatically.
  583. // If you are trying to implement your own backend for your own engine, you may ignore that noise.
  584. //---------------------------------------------------------------------------------------------------------
  585. // Perform our own check with RtlVerifyVersionInfo() instead of using functions from <VersionHelpers.h> as they
  586. // require a manifest to be functional for checks above 8.1. See https://github.com/ocornut/imgui/issues/4200
  587. static BOOL _IsWindowsVersionOrGreater(WORD major, WORD minor, WORD)
  588. {
  589. typedef LONG(WINAPI* PFN_RtlVerifyVersionInfo)(OSVERSIONINFOEXW*, ULONG, ULONGLONG);
  590. static PFN_RtlVerifyVersionInfo RtlVerifyVersionInfoFn = NULL;
  591. if (RtlVerifyVersionInfoFn == NULL)
  592. if (HMODULE ntdllModule = ::GetModuleHandleA("ntdll.dll"))
  593. RtlVerifyVersionInfoFn = (PFN_RtlVerifyVersionInfo)GetProcAddress(ntdllModule, "RtlVerifyVersionInfo");
  594. if (RtlVerifyVersionInfoFn == NULL)
  595. return FALSE;
  596. RTL_OSVERSIONINFOEXW versionInfo = { };
  597. ULONGLONG conditionMask = 0;
  598. versionInfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
  599. versionInfo.dwMajorVersion = major;
  600. versionInfo.dwMinorVersion = minor;
  601. VER_SET_CONDITION(conditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
  602. VER_SET_CONDITION(conditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
  603. return (RtlVerifyVersionInfoFn(&versionInfo, VER_MAJORVERSION | VER_MINORVERSION, conditionMask) == 0) ? TRUE : FALSE;
  604. }
  605. #define _IsWindowsVistaOrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0600), LOBYTE(0x0600), 0) // _WIN32_WINNT_VISTA
  606. #define _IsWindows8OrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0602), LOBYTE(0x0602), 0) // _WIN32_WINNT_WIN8
  607. #define _IsWindows8Point1OrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0603), LOBYTE(0x0603), 0) // _WIN32_WINNT_WINBLUE
  608. #define _IsWindows10OrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0A00), LOBYTE(0x0A00), 0) // _WIN32_WINNT_WINTHRESHOLD / _WIN32_WINNT_WIN10
  609. #ifndef DPI_ENUMS_DECLARED
  610. typedef enum { PROCESS_DPI_UNAWARE = 0, PROCESS_SYSTEM_DPI_AWARE = 1, PROCESS_PER_MONITOR_DPI_AWARE = 2 } PROCESS_DPI_AWARENESS;
  611. typedef enum { MDT_EFFECTIVE_DPI = 0, MDT_ANGULAR_DPI = 1, MDT_RAW_DPI = 2, MDT_DEFAULT = MDT_EFFECTIVE_DPI } MONITOR_DPI_TYPE;
  612. #endif
  613. #ifndef _DPI_AWARENESS_CONTEXTS_
  614. DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
  615. #define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE (DPI_AWARENESS_CONTEXT)-3
  616. #endif
  617. #ifndef DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
  618. #define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 (DPI_AWARENESS_CONTEXT)-4
  619. #endif
  620. typedef HRESULT(WINAPI* PFN_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS); // Shcore.lib + dll, Windows 8.1+
  621. typedef HRESULT(WINAPI* PFN_GetDpiForMonitor)(HMONITOR, MONITOR_DPI_TYPE, UINT*, UINT*); // Shcore.lib + dll, Windows 8.1+
  622. typedef DPI_AWARENESS_CONTEXT(WINAPI* PFN_SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT); // User32.lib + dll, Windows 10 v1607+ (Creators Update)
  623. // Helper function to enable DPI awareness without setting up a manifest
  624. void ImGui_ImplWin32_EnableDpiAwareness()
  625. {
  626. if (_IsWindows10OrGreater())
  627. {
  628. static HINSTANCE user32_dll = ::LoadLibraryA("user32.dll"); // Reference counted per-process
  629. if (PFN_SetThreadDpiAwarenessContext SetThreadDpiAwarenessContextFn = (PFN_SetThreadDpiAwarenessContext)::GetProcAddress(user32_dll, "SetThreadDpiAwarenessContext"))
  630. {
  631. SetThreadDpiAwarenessContextFn(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
  632. return;
  633. }
  634. }
  635. if (_IsWindows8Point1OrGreater())
  636. {
  637. static HINSTANCE shcore_dll = ::LoadLibraryA("shcore.dll"); // Reference counted per-process
  638. if (PFN_SetProcessDpiAwareness SetProcessDpiAwarenessFn = (PFN_SetProcessDpiAwareness)::GetProcAddress(shcore_dll, "SetProcessDpiAwareness"))
  639. {
  640. SetProcessDpiAwarenessFn(PROCESS_PER_MONITOR_DPI_AWARE);
  641. return;
  642. }
  643. }
  644. #if _WIN32_WINNT >= 0x0600
  645. ::SetProcessDPIAware();
  646. #endif
  647. }
  648. #if defined(_MSC_VER) && !defined(NOGDI)
  649. #pragma comment(lib, "gdi32") // Link with gdi32.lib for GetDeviceCaps(). MinGW will require linking with '-lgdi32'
  650. #endif
  651. float ImGui_ImplWin32_GetDpiScaleForMonitor(void* monitor)
  652. {
  653. UINT xdpi = 96, ydpi = 96;
  654. if (_IsWindows8Point1OrGreater())
  655. {
  656. static HINSTANCE shcore_dll = ::LoadLibraryA("shcore.dll"); // Reference counted per-process
  657. static PFN_GetDpiForMonitor GetDpiForMonitorFn = NULL;
  658. if (GetDpiForMonitorFn == NULL && shcore_dll != NULL)
  659. GetDpiForMonitorFn = (PFN_GetDpiForMonitor)::GetProcAddress(shcore_dll, "GetDpiForMonitor");
  660. if (GetDpiForMonitorFn != NULL)
  661. {
  662. GetDpiForMonitorFn((HMONITOR)monitor, MDT_EFFECTIVE_DPI, &xdpi, &ydpi);
  663. IM_ASSERT(xdpi == ydpi); // Please contact me if you hit this assert!
  664. return xdpi / 96.0f;
  665. }
  666. }
  667. #ifndef NOGDI
  668. const HDC dc = ::GetDC(NULL);
  669. xdpi = ::GetDeviceCaps(dc, LOGPIXELSX);
  670. ydpi = ::GetDeviceCaps(dc, LOGPIXELSY);
  671. IM_ASSERT(xdpi == ydpi); // Please contact me if you hit this assert!
  672. ::ReleaseDC(NULL, dc);
  673. #endif
  674. return xdpi / 96.0f;
  675. }
  676. float ImGui_ImplWin32_GetDpiScaleForHwnd(void* hwnd)
  677. {
  678. HMONITOR monitor = ::MonitorFromWindow((HWND)hwnd, MONITOR_DEFAULTTONEAREST);
  679. return ImGui_ImplWin32_GetDpiScaleForMonitor(monitor);
  680. }
  681. //---------------------------------------------------------------------------------------------------------
  682. // Transparency related helpers (optional)
  683. //--------------------------------------------------------------------------------------------------------
  684. #if defined(_MSC_VER)
  685. #pragma comment(lib, "dwmapi") // Link with dwmapi.lib. MinGW will require linking with '-ldwmapi'
  686. #endif
  687. // [experimental]
  688. // Borrowed from GLFW's function updateFramebufferTransparency() in src/win32_window.c
  689. // (the Dwm* functions are Vista era functions but we are borrowing logic from GLFW)
  690. void ImGui_ImplWin32_EnableAlphaCompositing(void* hwnd)
  691. {
  692. if (!_IsWindowsVistaOrGreater())
  693. return;
  694. BOOL composition;
  695. if (FAILED(::DwmIsCompositionEnabled(&composition)) || !composition)
  696. return;
  697. BOOL opaque;
  698. DWORD color;
  699. if (_IsWindows8OrGreater() || (SUCCEEDED(::DwmGetColorizationColor(&color, &opaque)) && !opaque))
  700. {
  701. HRGN region = ::CreateRectRgn(0, 0, -1, -1);
  702. DWM_BLURBEHIND bb = {};
  703. bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;
  704. bb.hRgnBlur = region;
  705. bb.fEnable = TRUE;
  706. ::DwmEnableBlurBehindWindow((HWND)hwnd, &bb);
  707. ::DeleteObject(region);
  708. }
  709. else
  710. {
  711. DWM_BLURBEHIND bb = {};
  712. bb.dwFlags = DWM_BB_ENABLE;
  713. ::DwmEnableBlurBehindWindow((HWND)hwnd, &bb);
  714. }
  715. }
  716. //---------------------------------------------------------------------------------------------------------