imgui_impl_win32.cpp 44 KB

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