suwako / ShaderPlayground

master
ブランチ master
ShaderPlayground / deps / imgui / imgui / backends / imgui_impl_glfw.cpp
91.8 KB、1727行 生 Blame 履歴
1// dear imgui: Platform Backend for GLFW
2// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
3// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
4// (Requires: GLFW 3.0+. Prefer GLFW 3.3+/3.4+ for full feature support.)
5
6// Implemented features:
7// [X] Platform: Clipboard support.
8// [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen (Windows only).
9// [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 GLFW_KEY_* values are obsolete since 1.87 and not supported since 1.91.5]
10// [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
11// [X] Platform: Mouse cursor shape and visibility (ImGuiBackendFlags_HasMouseCursors) with GLFW 3.1+. Resizing cursors requires GLFW 3.4+! Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
12// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
13// [X] Multiple Dear ImGui contexts support.
14// Missing features or Issues:
15// [ ] Platform: Touch events are only correctly identified as Touch on Windows. This create issues with some interactions. GLFW doesn't provide a way to identify touch inputs from mouse inputs, we cannot call io.AddMouseSourceEvent() to identify the source. We provide a Windows-specific workaround.
16// [ ] Platform: Missing ImGuiMouseCursor_Wait and ImGuiMouseCursor_Progress cursors.
17// [ ] Platform: Multi-viewport: Missing ImGuiBackendFlags_HasParentViewport support. The viewport->ParentViewportID field is ignored, and therefore io.ConfigViewportsNoDefaultParent has no effect either.
18
19// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
20// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
21// Learn about Dear ImGui:
22// - FAQ https://dearimgui.com/faq
23// - Getting Started https://dearimgui.com/getting-started
24// - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
25// - Introduction, links and more at the top of imgui.cpp
26
27// About Emscripten support:
28// - Emscripten provides its own GLFW (3.2.1) implementation (syntax: "-sUSE_GLFW=3"), but Joystick is broken and several features are not supported (multiple windows, clipboard, timer, etc.)
29// - A third-party Emscripten GLFW (3.4.0) implementation (syntax: "--use-port=contrib.glfw3") fixes the Joystick issue and implements all relevant features for the browser.
30// See https://github.com/pongasoft/emscripten-glfw/blob/master/docs/Comparison.md for details.
31
32// CHANGELOG
33// (minor and older changes stripped away, please see git history for details)
34// 2026-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
35// 2026-04-21: Added a Win32-specific implementation of ImGui_ImplGlfw_GetContentScaleXXXX functions for legacy GLFW 3.2.
36// 2026-03-25: Mouse cursor is properly restored if changed by user app/code while using glfwSetInputMode(..., GLFW_CURSOR_DISABLED) or ImGuiConfigFlags_NoMouseCursorChange. Amend change from 2025-12-10.
37// 2026-02-10: Try to set IMGUI_IMPL_GLFW_DISABLE_X11 / IMGUI_IMPL_GLFW_DISABLE_WAYLAND automatically if corresponding headers are not accessible. (#9225)
38// 2026-01-25: [Docking] Improve workarounds for cases where GLFW is unable to provide any reliable monitor info. Preserve existing monitor list when none of the new one is valid. (#9195, #7902, #5683)
39// 2026-01-18: [Docking] Dynamically load X11 functions to avoid -lx11 linking requirement introduced on 2025-09-10.
40// 2025-12-12: Added IMGUI_IMPL_GLFW_DISABLE_X11 / IMGUI_IMPL_GLFW_DISABLE_WAYLAND to forcefully disable either.
41// 2025-12-10: Avoid repeated glfwSetCursor()/glfwSetInputMode() calls when unnecessary. Lowers overhead for very high framerates (e.g. 10k+ FPS).
42// 2025-11-06: Lower minimum requirement to GLFW 3.0. Though a recent version e.g GLFW 3.4 is highly recommended.
43// 2025-09-18: Call platform_io.ClearPlatformHandlers() on shutdown.
44// 2025-09-15: Content Scales are always reported as 1.0 on Wayland. FramebufferScale are always reported as 1.0 on X11. (#8920, #8921)
45// 2025-09-10: [Docking] Improve multi-viewport behavior in tiling WMs on X11 via the ImGui_ImplGlfw_SetWindowFloating() function. Note: using GLFW backend on Linux/BSD etc. requires linking with -lX11. (#8884, #8474, #8289)
46// 2025-07-08: Made ImGui_ImplGlfw_GetContentScaleForWindow(), ImGui_ImplGlfw_GetContentScaleForMonitor() helpers return 1.0f on Emscripten and Android platforms, matching macOS logic. (#8742, #8733)
47// 2025-06-18: Added support for multiple Dear ImGui contexts. (#8676, #8239, #8069)
48// 2025-06-11: Added ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window) and ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor) helper to facilitate making DPI-aware apps.
49// 2025-05-15: [Docking] Add Platform_GetWindowFramebufferScale() handler, to allow varying Retina display density on multiple monitors.
50// 2025-04-26: [Docking] Disable multi-viewports under Wayland. (#8587)
51// 2025-03-10: Map GLFW_KEY_WORLD_1 and GLFW_KEY_WORLD_2 into ImGuiKey_Oem102.
52// 2025-03-03: Fixed clipboard handler assertion when using GLFW <= 3.2.1 compiled with asserts enabled.
53// 2025-02-21: [Docking] Update monitors and work areas information every frame, as the later may change regardless of monitor changes. (#8415)
54// 2024-11-05: [Docking] Added Linux workaround for spurious mouse up events emitted while dragging and creating new viewport. (#3158, #7733, #7922)
55// 2024-08-22: Moved some OS/backend related function pointers from ImGuiIO to ImGuiPlatformIO:
56// - io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn
57// - io.SetClipboardTextFn -> platform_io.Platform_SetClipboardTextFn
58// - io.PlatformOpenInShellFn -> platform_io.Platform_OpenInShellFn
59// 2024-07-31: Added ImGui_ImplGlfw_Sleep() helper function for usage by our examples app, since GLFW doesn't provide one.
60// 2024-07-08: *BREAKING* Renamed ImGui_ImplGlfw_InstallEmscriptenCanvasResizeCallback to ImGui_ImplGlfw_InstallEmscriptenCallbacks(), added GLFWWindow* parameter.
61// 2024-07-08: Emscripten: Added support for GLFW3 contrib port (GLFW 3.4.0 features + bug fixes): to enable, replace -sUSE_GLFW=3 with --use-port=contrib.glfw3 (requires emscripten 3.1.59+) (https://github.com/pongasoft/emscripten-glfw)
62// 2024-07-02: Emscripten: Added io.PlatformOpenInShellFn() handler for Emscripten versions.
63// 2023-12-19: Emscripten: Added ImGui_ImplGlfw_InstallEmscriptenCanvasResizeCallback() to register canvas selector and auto-resize GLFW window.
64// 2023-10-05: Inputs: Added support for extra ImGuiKey values: F13 to F24 function keys.
65// 2023-07-18: Inputs: Revert ignoring mouse data on GLFW_CURSOR_DISABLED as it can be used differently. User may set ImGuiConfigFLags_NoMouse if desired. (#5625, #6609)
66// 2023-06-12: Accept glfwGetTime() not returning a monotonically increasing value. This seems to happens on some Windows setup when peripherals disconnect, and is likely to also happen on browser + Emscripten. (#6491)
67// 2023-04-04: Inputs: Added support for io.AddMouseSourceEvent() to discriminate ImGuiMouseSource_Mouse/ImGuiMouseSource_TouchScreen/ImGuiMouseSource_Pen on Windows ONLY, using a custom WndProc hook. (#2702)
68// 2023-03-16: Inputs: Fixed key modifiers handling on secondary viewports (docking branch). Broken on 2023/01/04. (#6248, #6034)
69// 2023-03-14: Emscripten: Avoid using glfwGetError() and glfwGetGamepadState() which are not correctly implemented in Emscripten emulation. (#6240)
70// 2023-02-03: Emscripten: Registering custom low-level mouse wheel handler to get more accurate scrolling impulses on Emscripten. (#4019, #6096)
71// 2023-01-18: Handle unsupported glfwGetVideoMode() call on e.g. Emscripten.
72// 2023-01-04: Inputs: Fixed mods state on Linux when using Alt-GR text input (e.g. German keyboard layout), could lead to broken text input. Revert a 2022/01/17 change were we resumed using mods provided by GLFW, turns out they were faulty.
73// 2022-11-22: Perform a dummy glfwGetError() read to cancel missing names with glfwGetKeyName(). (#5908)
74// 2022-10-18: Perform a dummy glfwGetError() read to cancel missing mouse cursors errors. Using GLFW_VERSION_COMBINED directly. (#5785)
75// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
76// 2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
77// 2022-09-01: Inputs: Honor GLFW_CURSOR_DISABLED by not setting mouse position *EDIT* Reverted 2023-07-18.
78// 2022-04-30: Inputs: Fixed ImGui_ImplGlfw_TranslateUntranslatedKey() for lower case letters on OSX.
79// 2022-03-23: Inputs: Fixed a regression in 1.87 which resulted in keyboard modifiers events being reported incorrectly on Linux/X11.
80// 2022-02-07: Added ImGui_ImplGlfw_InstallCallbacks()/ImGui_ImplGlfw_RestoreCallbacks() helpers to facilitate user installing callbacks after initializing backend.
81// 2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
82// 2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
83// 2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
84// 2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
85// 2022-01-12: *BREAKING CHANGE*: Now using glfwSetCursorPosCallback(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetCursorPosCallback() and forward it to the backend via ImGui_ImplGlfw_CursorPosCallback().
86// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
87// 2022-01-05: Inputs: Converting GLFW untranslated keycodes back to translated keycodes (in the ImGui_ImplGlfw_KeyCallback() function) in order to match the behavior of every other backend, and facilitate the use of GLFW with lettered-shortcuts API.
88// 2021-08-17: *BREAKING CHANGE*: Now using glfwSetWindowFocusCallback() to calling io.AddFocusEvent(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() and forward it to the backend via ImGui_ImplGlfw_WindowFocusCallback().
89// 2021-07-29: *BREAKING CHANGE*: Now using glfwSetCursorEnterCallback(). MousePos is correctly reported when the host platform window is hovered but not focused. If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() callback and forward it to the backend via ImGui_ImplGlfw_CursorEnterCallback().
90// 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).
91// 2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
92// 2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
93// 2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
94// 2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
95// 2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
96// 2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
97// 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
98// 2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
99// 2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
100// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
101// 2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
102// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
103// 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
104// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
105// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
106// 2018-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
107// 2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
108// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
109// 2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
110// 2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
111// 2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
112
113#include "imgui.h"
114#ifndef IMGUI_DISABLE
115#include "imgui_impl_glfw.h"
116
117// Clang warnings with -Weverything
118#if defined(__clang__)
119#pragma clang diagnostic push
120#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast
121#pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
122#pragma clang diagnostic ignored "-Wexit-time-destructors" // warning: declaration requires an exit-time destructor // exit-time destruction order is undefined. if MemFree() leads to users code that has been disabled before exit it might cause problems. ImGui coding style welcomes static/globals.
123#pragma clang diagnostic ignored "-Wglobal-constructors" // warning: declaration requires a global destructor // similar to above, not sure what the exact difference is.
124#elif defined(__GNUC__)
125#pragma GCC diagnostic ignored "-Wfloat-equal" // warning: comparing floating-point with '==' or '!=' is unsafe
126#endif
127
128#if defined(__has_include)
129#if !__has_include(<X11/Xlib.h>) || !__has_include(<X11/extensions/Xrandr.h>)
130#define IMGUI_IMPL_GLFW_DISABLE_X11
131#endif
132#if !__has_include(<wayland-client.h>)
133#define IMGUI_IMPL_GLFW_DISABLE_WAYLAND
134#endif
135#endif
136
137// GLFW
138#if !defined(IMGUI_IMPL_GLFW_DISABLE_X11) && (defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__))
139#define GLFW_HAS_X11 1
140#else
141#define GLFW_HAS_X11 0
142#endif
143#if !defined(IMGUI_IMPL_GLFW_DISABLE_WAYLAND) && (defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__))
144#define GLFW_HAS_WAYLAND 1
145#else
146#define GLFW_HAS_WAYLAND 0
147#endif
148#include <GLFW/glfw3.h>
149#ifdef _WIN32
150#undef APIENTRY
151#ifndef GLFW_EXPOSE_NATIVE_WIN32 // for glfwGetWin32Window()
152#define GLFW_EXPOSE_NATIVE_WIN32
153#endif
154#include <GLFW/glfw3native.h>
155#elif defined(__APPLE__)
156#ifndef GLFW_EXPOSE_NATIVE_COCOA // for glfwGetCocoaWindow()
157#define GLFW_EXPOSE_NATIVE_COCOA
158#endif
159#include <GLFW/glfw3native.h>
160#elif GLFW_HAS_X11
161#ifndef GLFW_EXPOSE_NATIVE_X11 // for glfwGetX11Display(), glfwGetX11Window() on Freedesktop (Linux, BSD, etc.)
162#define GLFW_EXPOSE_NATIVE_X11
163#include <X11/Xatom.h>
164#include <dlfcn.h> // for dlopen()
165#endif
166#include <GLFW/glfw3native.h>
167#undef Status // X11 headers are leaking this.
168#endif
169
170#ifndef _WIN32
171#include <unistd.h> // for usleep()
172#endif
173#include <stdio.h> // for snprintf()
174
175#ifdef __EMSCRIPTEN__
176#include <emscripten.h>
177#include <emscripten/html5.h>
178#ifdef EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3
179#include <GLFW/emscripten_glfw3.h>
180#else
181#define EMSCRIPTEN_USE_EMBEDDED_GLFW3
182#endif
183#endif
184
185// We gather version tests as define in order to easily see which features are version-dependent.
186#define GLFW_VERSION_COMBINED (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 + GLFW_VERSION_REVISION)
187#define GLFW_HAS_CREATECURSOR (GLFW_VERSION_COMBINED >= 3100) // 3.1+ glfwCreateCursor()
188#define GLFW_HAS_WINDOW_TOPMOST (GLFW_VERSION_COMBINED >= 3200) // 3.2+ GLFW_FLOATING
189#define GLFW_HAS_WINDOW_HOVERED (GLFW_VERSION_COMBINED >= 3300) // 3.3+ GLFW_HOVERED
190#define GLFW_HAS_WINDOW_ALPHA (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwSetWindowOpacity
191#define GLFW_HAS_PER_MONITOR_DPI (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetMonitorContentScale
192#if defined(__EMSCRIPTEN__) || defined(__SWITCH__) // no Vulkan support in GLFW for Emscripten or homebrew Nintendo Switch
193#define GLFW_HAS_VULKAN (0)
194#else
195#define GLFW_HAS_VULKAN (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwCreateWindowSurface
196#endif
197#define GLFW_HAS_FOCUS_WINDOW (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwFocusWindow
198#define GLFW_HAS_FOCUS_ON_SHOW (GLFW_VERSION_COMBINED >= 3300) // 3.3+ GLFW_FOCUS_ON_SHOW
199#define GLFW_HAS_MONITOR_WORK_AREA (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetMonitorWorkarea
200#define GLFW_HAS_OSX_WINDOW_POS_FIX (GLFW_VERSION_COMBINED >= 3301) // 3.3.1+ Fixed: Resizing window repositions it on MacOS #1553
201#ifdef GLFW_RESIZE_NESW_CURSOR // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2019-11-29 (cursors defines) // FIXME: Remove when GLFW 3.4 is released?
202#define GLFW_HAS_NEW_CURSORS (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
203#else
204#define GLFW_HAS_NEW_CURSORS (0)
205#endif
206#ifdef GLFW_MOUSE_PASSTHROUGH // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2020-07-17 (passthrough)
207#define GLFW_HAS_MOUSE_PASSTHROUGH (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_MOUSE_PASSTHROUGH
208#else
209#define GLFW_HAS_MOUSE_PASSTHROUGH (0)
210#endif
211#define GLFW_HAS_GAMEPAD_API (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetGamepadState() new api
212#define GLFW_HAS_GETKEYNAME (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwGetKeyName()
213#define GLFW_HAS_GETERROR (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetError()
214#define GLFW_HAS_GETPLATFORM (GLFW_VERSION_COMBINED >= 3400) // 3.4+ glfwGetPlatform()
215
216// Map GLFWWindow* to ImGuiContext*.
217// - Would be simpler if we could use glfwSetWindowUserPointer()/glfwGetWindowUserPointer(), but this is a single and shared resource.
218// - Would be simpler if we could use e.g. std::map<> as well. But we don't.
219// - This is not particularly optimized as we expect size to be small and queries to be rare.
220struct ImGui_ImplGlfw_WindowToContext { GLFWwindow* Window; ImGuiContext* Context; };
221static ImVector<ImGui_ImplGlfw_WindowToContext> g_ContextMap;
222static void ImGui_ImplGlfw_ContextMap_Add(GLFWwindow* window, ImGuiContext* ctx) { g_ContextMap.push_back(ImGui_ImplGlfw_WindowToContext{ window, ctx }); }
223static void ImGui_ImplGlfw_ContextMap_Remove(GLFWwindow* window) { for (ImGui_ImplGlfw_WindowToContext& entry : g_ContextMap) if (entry.Window == window) { g_ContextMap.erase_unsorted(&entry); if (g_ContextMap.empty()) g_ContextMap.clear(); return; } }
224static ImGuiContext* ImGui_ImplGlfw_ContextMap_Get(GLFWwindow* window) { for (ImGui_ImplGlfw_WindowToContext& entry : g_ContextMap) if (entry.Window == window) return entry.Context; return nullptr; }
225
226enum GlfwClientApi
227{
228 GlfwClientApi_OpenGL,
229 GlfwClientApi_Vulkan,
230 GlfwClientApi_Unknown, // Anything else fits here.
231};
232
233#if GLFW_HAS_X11
234typedef Atom (*PFN_XInternAtom)(Display*, const char* ,Bool);
235typedef int (*PFN_XChangeProperty)(Display*, Window, Atom, Atom, int, int, const unsigned char*, int);
236typedef int (*PFN_XChangeWindowAttributes)(Display*, Window, unsigned long, XSetWindowAttributes*);
237typedef int (*PFN_XFlush)(Display*);
238#endif
239
240// GLFW data
241struct ImGui_ImplGlfw_Data
242{
243 ImGuiContext* Context;
244 GLFWwindow* Window;
245 GlfwClientApi ClientApi;
246 double Time;
247 GLFWwindow* MouseWindow;
248#if GLFW_HAS_CREATECURSOR
249 GLFWcursor* MouseCursors[ImGuiMouseCursor_COUNT];
250 GLFWcursor* LastMouseCursor;
251#endif
252 bool MouseIgnoreButtonUpWaitForFocusLoss;
253 bool MouseIgnoreButtonUp;
254 ImVec2 LastValidMousePos;
255 GLFWwindow* KeyOwnerWindows[GLFW_KEY_LAST];
256 bool IsWayland;
257 bool InstalledCallbacks;
258 bool CallbacksChainForAllWindows;
259 char BackendPlatformName[32];
260#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
261 const char* CanvasSelector;
262#endif
263
264 // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
265 GLFWwindowfocusfun PrevUserCallbackWindowFocus;
266 GLFWcursorposfun PrevUserCallbackCursorPos;
267 GLFWcursorenterfun PrevUserCallbackCursorEnter;
268 GLFWmousebuttonfun PrevUserCallbackMousebutton;
269 GLFWscrollfun PrevUserCallbackScroll;
270 GLFWkeyfun PrevUserCallbackKey;
271 GLFWcharfun PrevUserCallbackChar;
272 GLFWmonitorfun PrevUserCallbackMonitor;
273#ifdef _WIN32
274 WNDPROC PrevWndProc;
275#endif
276
277#if GLFW_HAS_X11
278 // Module and function pointers loaded at initialization to avoid linking statically with X11.
279 void* X11Module;
280 PFN_XInternAtom XInternAtom;
281 PFN_XChangeProperty XChangeProperty;
282 PFN_XChangeWindowAttributes XChangeWindowAttributes;
283 PFN_XFlush XFlush;
284#endif
285
286 ImGui_ImplGlfw_Data() { memset((void*)this, 0, sizeof(*this)); }
287};
288
289// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
290// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
291// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
292// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
293// (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
294// - Otherwise we may need to store a GLFWWindow* -> ImGuiContext* map and handle this in the backend, adding a little bit of extra complexity to it.
295// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
296namespace ImGui { extern ImGuiIO& GetIO(ImGuiContext*); }
297static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData()
298{
299 // Get data for current context
300 return ImGui::GetCurrentContext() ? (ImGui_ImplGlfw_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
301}
302static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData(GLFWwindow* window)
303{
304 // Get data for a given GLFW window, regardless of current context (since GLFW events are sent together)
305 ImGuiContext* ctx = ImGui_ImplGlfw_ContextMap_Get(window);
306 return (ImGui_ImplGlfw_Data*)ImGui::GetIO(ctx).BackendPlatformUserData;
307}
308
309// Forward Declarations
310static void ImGui_ImplGlfw_UpdateMonitors();
311static void ImGui_ImplGlfw_InitMultiViewportSupport();
312static void ImGui_ImplGlfw_ShutdownMultiViewportSupport();
313
314// Functions
315static bool ImGui_ImplGlfw_IsWayland()
316{
317#if !GLFW_HAS_WAYLAND
318 return false;
319#elif GLFW_HAS_GETPLATFORM
320 return glfwGetPlatform() == GLFW_PLATFORM_WAYLAND;
321#else
322 const char* version = glfwGetVersionString();
323 if (strstr(version, "Wayland") == nullptr) // e.g. Ubuntu 22.04 ships with GLFW 3.3.6 compiled without Wayland
324 return false;
325#ifdef GLFW_EXPOSE_NATIVE_X11
326 if (glfwGetX11Display() != nullptr)
327 return false;
328#endif
329 return true;
330#endif
331}
332
333// Not static to allow third-party code to use that if they want to (but undocumented)
334ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int keycode, int scancode);
335ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int keycode, int scancode)
336{
337 IM_UNUSED(scancode);
338 switch (keycode)
339 {
340 case GLFW_KEY_TAB: return ImGuiKey_Tab;
341 case GLFW_KEY_LEFT: return ImGuiKey_LeftArrow;
342 case GLFW_KEY_RIGHT: return ImGuiKey_RightArrow;
343 case GLFW_KEY_UP: return ImGuiKey_UpArrow;
344 case GLFW_KEY_DOWN: return ImGuiKey_DownArrow;
345 case GLFW_KEY_PAGE_UP: return ImGuiKey_PageUp;
346 case GLFW_KEY_PAGE_DOWN: return ImGuiKey_PageDown;
347 case GLFW_KEY_HOME: return ImGuiKey_Home;
348 case GLFW_KEY_END: return ImGuiKey_End;
349 case GLFW_KEY_INSERT: return ImGuiKey_Insert;
350 case GLFW_KEY_DELETE: return ImGuiKey_Delete;
351 case GLFW_KEY_BACKSPACE: return ImGuiKey_Backspace;
352 case GLFW_KEY_SPACE: return ImGuiKey_Space;
353 case GLFW_KEY_ENTER: return ImGuiKey_Enter;
354 case GLFW_KEY_ESCAPE: return ImGuiKey_Escape;
355 case GLFW_KEY_APOSTROPHE: return ImGuiKey_Apostrophe;
356 case GLFW_KEY_COMMA: return ImGuiKey_Comma;
357 case GLFW_KEY_MINUS: return ImGuiKey_Minus;
358 case GLFW_KEY_PERIOD: return ImGuiKey_Period;
359 case GLFW_KEY_SLASH: return ImGuiKey_Slash;
360 case GLFW_KEY_SEMICOLON: return ImGuiKey_Semicolon;
361 case GLFW_KEY_EQUAL: return ImGuiKey_Equal;
362 case GLFW_KEY_LEFT_BRACKET: return ImGuiKey_LeftBracket;
363 case GLFW_KEY_BACKSLASH: return ImGuiKey_Backslash;
364 case GLFW_KEY_WORLD_1: return ImGuiKey_Oem102;
365 case GLFW_KEY_WORLD_2: return ImGuiKey_Oem102;
366 case GLFW_KEY_RIGHT_BRACKET: return ImGuiKey_RightBracket;
367 case GLFW_KEY_GRAVE_ACCENT: return ImGuiKey_GraveAccent;
368 case GLFW_KEY_CAPS_LOCK: return ImGuiKey_CapsLock;
369 case GLFW_KEY_SCROLL_LOCK: return ImGuiKey_ScrollLock;
370 case GLFW_KEY_NUM_LOCK: return ImGuiKey_NumLock;
371 case GLFW_KEY_PRINT_SCREEN: return ImGuiKey_PrintScreen;
372 case GLFW_KEY_PAUSE: return ImGuiKey_Pause;
373 case GLFW_KEY_KP_0: return ImGuiKey_Keypad0;
374 case GLFW_KEY_KP_1: return ImGuiKey_Keypad1;
375 case GLFW_KEY_KP_2: return ImGuiKey_Keypad2;
376 case GLFW_KEY_KP_3: return ImGuiKey_Keypad3;
377 case GLFW_KEY_KP_4: return ImGuiKey_Keypad4;
378 case GLFW_KEY_KP_5: return ImGuiKey_Keypad5;
379 case GLFW_KEY_KP_6: return ImGuiKey_Keypad6;
380 case GLFW_KEY_KP_7: return ImGuiKey_Keypad7;
381 case GLFW_KEY_KP_8: return ImGuiKey_Keypad8;
382 case GLFW_KEY_KP_9: return ImGuiKey_Keypad9;
383 case GLFW_KEY_KP_DECIMAL: return ImGuiKey_KeypadDecimal;
384 case GLFW_KEY_KP_DIVIDE: return ImGuiKey_KeypadDivide;
385 case GLFW_KEY_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
386 case GLFW_KEY_KP_SUBTRACT: return ImGuiKey_KeypadSubtract;
387 case GLFW_KEY_KP_ADD: return ImGuiKey_KeypadAdd;
388 case GLFW_KEY_KP_ENTER: return ImGuiKey_KeypadEnter;
389 case GLFW_KEY_KP_EQUAL: return ImGuiKey_KeypadEqual;
390 case GLFW_KEY_LEFT_SHIFT: return ImGuiKey_LeftShift;
391 case GLFW_KEY_LEFT_CONTROL: return ImGuiKey_LeftCtrl;
392 case GLFW_KEY_LEFT_ALT: return ImGuiKey_LeftAlt;
393 case GLFW_KEY_LEFT_SUPER: return ImGuiKey_LeftSuper;
394 case GLFW_KEY_RIGHT_SHIFT: return ImGuiKey_RightShift;
395 case GLFW_KEY_RIGHT_CONTROL: return ImGuiKey_RightCtrl;
396 case GLFW_KEY_RIGHT_ALT: return ImGuiKey_RightAlt;
397 case GLFW_KEY_RIGHT_SUPER: return ImGuiKey_RightSuper;
398 case GLFW_KEY_MENU: return ImGuiKey_Menu;
399 case GLFW_KEY_0: return ImGuiKey_0;
400 case GLFW_KEY_1: return ImGuiKey_1;
401 case GLFW_KEY_2: return ImGuiKey_2;
402 case GLFW_KEY_3: return ImGuiKey_3;
403 case GLFW_KEY_4: return ImGuiKey_4;
404 case GLFW_KEY_5: return ImGuiKey_5;
405 case GLFW_KEY_6: return ImGuiKey_6;
406 case GLFW_KEY_7: return ImGuiKey_7;
407 case GLFW_KEY_8: return ImGuiKey_8;
408 case GLFW_KEY_9: return ImGuiKey_9;
409 case GLFW_KEY_A: return ImGuiKey_A;
410 case GLFW_KEY_B: return ImGuiKey_B;
411 case GLFW_KEY_C: return ImGuiKey_C;
412 case GLFW_KEY_D: return ImGuiKey_D;
413 case GLFW_KEY_E: return ImGuiKey_E;
414 case GLFW_KEY_F: return ImGuiKey_F;
415 case GLFW_KEY_G: return ImGuiKey_G;
416 case GLFW_KEY_H: return ImGuiKey_H;
417 case GLFW_KEY_I: return ImGuiKey_I;
418 case GLFW_KEY_J: return ImGuiKey_J;
419 case GLFW_KEY_K: return ImGuiKey_K;
420 case GLFW_KEY_L: return ImGuiKey_L;
421 case GLFW_KEY_M: return ImGuiKey_M;
422 case GLFW_KEY_N: return ImGuiKey_N;
423 case GLFW_KEY_O: return ImGuiKey_O;
424 case GLFW_KEY_P: return ImGuiKey_P;
425 case GLFW_KEY_Q: return ImGuiKey_Q;
426 case GLFW_KEY_R: return ImGuiKey_R;
427 case GLFW_KEY_S: return ImGuiKey_S;
428 case GLFW_KEY_T: return ImGuiKey_T;
429 case GLFW_KEY_U: return ImGuiKey_U;
430 case GLFW_KEY_V: return ImGuiKey_V;
431 case GLFW_KEY_W: return ImGuiKey_W;
432 case GLFW_KEY_X: return ImGuiKey_X;
433 case GLFW_KEY_Y: return ImGuiKey_Y;
434 case GLFW_KEY_Z: return ImGuiKey_Z;
435 case GLFW_KEY_F1: return ImGuiKey_F1;
436 case GLFW_KEY_F2: return ImGuiKey_F2;
437 case GLFW_KEY_F3: return ImGuiKey_F3;
438 case GLFW_KEY_F4: return ImGuiKey_F4;
439 case GLFW_KEY_F5: return ImGuiKey_F5;
440 case GLFW_KEY_F6: return ImGuiKey_F6;
441 case GLFW_KEY_F7: return ImGuiKey_F7;
442 case GLFW_KEY_F8: return ImGuiKey_F8;
443 case GLFW_KEY_F9: return ImGuiKey_F9;
444 case GLFW_KEY_F10: return ImGuiKey_F10;
445 case GLFW_KEY_F11: return ImGuiKey_F11;
446 case GLFW_KEY_F12: return ImGuiKey_F12;
447 case GLFW_KEY_F13: return ImGuiKey_F13;
448 case GLFW_KEY_F14: return ImGuiKey_F14;
449 case GLFW_KEY_F15: return ImGuiKey_F15;
450 case GLFW_KEY_F16: return ImGuiKey_F16;
451 case GLFW_KEY_F17: return ImGuiKey_F17;
452 case GLFW_KEY_F18: return ImGuiKey_F18;
453 case GLFW_KEY_F19: return ImGuiKey_F19;
454 case GLFW_KEY_F20: return ImGuiKey_F20;
455 case GLFW_KEY_F21: return ImGuiKey_F21;
456 case GLFW_KEY_F22: return ImGuiKey_F22;
457 case GLFW_KEY_F23: return ImGuiKey_F23;
458 case GLFW_KEY_F24: return ImGuiKey_F24;
459 default: return ImGuiKey_None;
460 }
461}
462
463// X11 does not include current pressed/released modifier key in 'mods' flags submitted by GLFW
464// See https://github.com/ocornut/imgui/issues/6034 and https://github.com/glfw/glfw/issues/1630
465static void ImGui_ImplGlfw_UpdateKeyModifiers(ImGuiIO& io, GLFWwindow* window)
466{
467 io.AddKeyEvent(ImGuiMod_Ctrl, (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS));
468 io.AddKeyEvent(ImGuiMod_Shift, (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS));
469 io.AddKeyEvent(ImGuiMod_Alt, (glfwGetKey(window, GLFW_KEY_LEFT_ALT) == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_ALT) == GLFW_PRESS));
470 io.AddKeyEvent(ImGuiMod_Super, (glfwGetKey(window, GLFW_KEY_LEFT_SUPER) == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_SUPER) == GLFW_PRESS));
471}
472
473static bool ImGui_ImplGlfw_ShouldChainCallback(ImGui_ImplGlfw_Data* bd, GLFWwindow* window)
474{
475 return bd->CallbacksChainForAllWindows ? true : (window == bd->Window);
476}
477
478void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
479{
480 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
481 if (bd->PrevUserCallbackMousebutton != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
482 bd->PrevUserCallbackMousebutton(window, button, action, mods);
483
484 // Workaround for Linux: ignore mouse up events which are following an focus loss following a viewport creation
485 if (bd->MouseIgnoreButtonUp && action == GLFW_RELEASE)
486 return;
487
488 ImGuiIO& io = ImGui::GetIO(bd->Context);
489 ImGui_ImplGlfw_UpdateKeyModifiers(io, window);
490 if (button >= 0 && button < ImGuiMouseButton_COUNT)
491 io.AddMouseButtonEvent(button, action == GLFW_PRESS);
492}
493
494void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
495{
496 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
497 if (bd->PrevUserCallbackScroll != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
498 bd->PrevUserCallbackScroll(window, xoffset, yoffset);
499
500#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
501 // Ignore GLFW events: will be processed in ImGui_ImplEmscripten_WheelCallback().
502 return;
503#endif
504
505 ImGuiIO& io = ImGui::GetIO(bd->Context);
506 io.AddMouseWheelEvent((float)xoffset, (float)yoffset);
507}
508
509// FIXME: should this be baked into ImGui_ImplGlfw_KeyToImGuiKey()? then what about the values passed to io.SetKeyEventNativeData()?
510static int ImGui_ImplGlfw_TranslateUntranslatedKey(int key, int scancode)
511{
512#if GLFW_HAS_GETKEYNAME && !defined(EMSCRIPTEN_USE_EMBEDDED_GLFW3)
513 // GLFW 3.1+ attempts to "untranslate" keys, which goes the opposite of what every other framework does, making using lettered shortcuts difficult.
514 // (It had reasons to do so: namely GLFW is/was more likely to be used for WASD-type game controls rather than lettered shortcuts, but IHMO the 3.1 change could have been done differently)
515 // See https://github.com/glfw/glfw/issues/1502 for details.
516 // Adding a workaround to undo this (so our keys are translated->untranslated->translated, likely a lossy process).
517 // This won't cover edge cases but this is at least going to cover common cases.
518 if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_EQUAL)
519 return key;
520 GLFWerrorfun prev_error_callback = glfwSetErrorCallback(nullptr);
521 const char* key_name = glfwGetKeyName(key, scancode);
522 glfwSetErrorCallback(prev_error_callback);
523#if GLFW_HAS_GETERROR && !defined(EMSCRIPTEN_USE_EMBEDDED_GLFW3) // Eat errors (see #5908)
524 (void)glfwGetError(nullptr);
525#endif
526 if (key_name && key_name[0] != 0 && key_name[1] == 0)
527 {
528 const char char_names[] = "`-=[]\\,;\'./";
529 const int char_keys[] = { GLFW_KEY_GRAVE_ACCENT, GLFW_KEY_MINUS, GLFW_KEY_EQUAL, GLFW_KEY_LEFT_BRACKET, GLFW_KEY_RIGHT_BRACKET, GLFW_KEY_BACKSLASH, GLFW_KEY_COMMA, GLFW_KEY_SEMICOLON, GLFW_KEY_APOSTROPHE, GLFW_KEY_PERIOD, GLFW_KEY_SLASH, 0 };
530 IM_ASSERT(IM_COUNTOF(char_names) == IM_COUNTOF(char_keys));
531 if (key_name[0] >= '0' && key_name[0] <= '9') { key = GLFW_KEY_0 + (key_name[0] - '0'); }
532 else if (key_name[0] >= 'A' && key_name[0] <= 'Z') { key = GLFW_KEY_A + (key_name[0] - 'A'); }
533 else if (key_name[0] >= 'a' && key_name[0] <= 'z') { key = GLFW_KEY_A + (key_name[0] - 'a'); }
534 else if (const char* p = strchr(char_names, key_name[0])) { key = char_keys[p - char_names]; }
535 }
536 // if (action == GLFW_PRESS) printf("key %d scancode %d name '%s'\n", key, scancode, key_name);
537#else
538 IM_UNUSED(scancode);
539#endif
540 return key;
541}
542
543void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int keycode, int scancode, int action, int mods)
544{
545 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
546 if (bd->PrevUserCallbackKey != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
547 bd->PrevUserCallbackKey(window, keycode, scancode, action, mods);
548
549 if (action != GLFW_PRESS && action != GLFW_RELEASE)
550 return;
551
552 ImGuiIO& io = ImGui::GetIO(bd->Context);
553 ImGui_ImplGlfw_UpdateKeyModifiers(io, window);
554
555 if (keycode >= 0 && keycode < IM_COUNTOF(bd->KeyOwnerWindows))
556 bd->KeyOwnerWindows[keycode] = (action == GLFW_PRESS) ? window : nullptr;
557
558 keycode = ImGui_ImplGlfw_TranslateUntranslatedKey(keycode, scancode);
559
560 ImGuiKey imgui_key = ImGui_ImplGlfw_KeyToImGuiKey(keycode, scancode);
561 io.AddKeyEvent(imgui_key, (action == GLFW_PRESS));
562 io.SetKeyEventNativeData(imgui_key, keycode, scancode); // To support legacy indexing (<1.87 user code)
563}
564
565void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused)
566{
567 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
568 if (bd->PrevUserCallbackWindowFocus != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
569 bd->PrevUserCallbackWindowFocus(window, focused);
570
571 // Workaround for Linux: when losing focus with MouseIgnoreButtonUpWaitForFocusLoss set, we will temporarily ignore subsequent Mouse Up events
572 bd->MouseIgnoreButtonUp = (bd->MouseIgnoreButtonUpWaitForFocusLoss && focused == 0);
573 bd->MouseIgnoreButtonUpWaitForFocusLoss = false;
574
575 ImGuiIO& io = ImGui::GetIO(bd->Context);
576 io.AddFocusEvent(focused != 0);
577}
578
579void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y)
580{
581 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
582 if (bd->PrevUserCallbackCursorPos != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
583 bd->PrevUserCallbackCursorPos(window, x, y);
584
585 ImGuiIO& io = ImGui::GetIO(bd->Context);
586 if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
587 {
588 int window_x, window_y;
589 glfwGetWindowPos(window, &window_x, &window_y);
590 x += window_x;
591 y += window_y;
592 }
593 io.AddMousePosEvent((float)x, (float)y);
594 bd->LastValidMousePos = ImVec2((float)x, (float)y);
595}
596
597// Workaround: X11 seems to send spurious Leave/Enter events which would make us lose our position,
598// so we back it up and restore on Leave/Enter (see https://github.com/ocornut/imgui/issues/4984)
599void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered)
600{
601 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
602 if (bd->PrevUserCallbackCursorEnter != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
603 bd->PrevUserCallbackCursorEnter(window, entered);
604
605 ImGuiIO& io = ImGui::GetIO(bd->Context);
606 if (entered)
607 {
608 bd->MouseWindow = window;
609 io.AddMousePosEvent(bd->LastValidMousePos.x, bd->LastValidMousePos.y);
610 }
611 else if (!entered && bd->MouseWindow == window)
612 {
613 bd->LastValidMousePos = io.MousePos;
614 bd->MouseWindow = nullptr;
615 io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
616 }
617}
618
619void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
620{
621 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
622 if (bd->PrevUserCallbackChar != nullptr && ImGui_ImplGlfw_ShouldChainCallback(bd, window))
623 bd->PrevUserCallbackChar(window, c);
624
625 ImGuiIO& io = ImGui::GetIO(bd->Context);
626 io.AddInputCharacter(c);
627}
628
629void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor*, int)
630{
631 // This function is technically part of the API even if we stopped using the callback, so leaving it around.
632}
633
634#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
635static EM_BOOL ImGui_ImplEmscripten_WheelCallback(int, const EmscriptenWheelEvent* ev, void* user_data)
636{
637 // Mimic Emscripten_HandleWheel() in SDL.
638 // Corresponding equivalent in GLFW JS emulation layer has incorrect quantizing preventing small values. See #6096
639 ImGui_ImplGlfw_Data* bd = (ImGui_ImplGlfw_Data*)user_data;
640 float multiplier = 0.0f;
641 if (ev->deltaMode == DOM_DELTA_PIXEL) { multiplier = 1.0f / 100.0f; } // 100 pixels make up a step.
642 else if (ev->deltaMode == DOM_DELTA_LINE) { multiplier = 1.0f / 3.0f; } // 3 lines make up a step.
643 else if (ev->deltaMode == DOM_DELTA_PAGE) { multiplier = 80.0f; } // A page makes up 80 steps.
644 float wheel_x = ev->deltaX * -multiplier;
645 float wheel_y = ev->deltaY * -multiplier;
646 ImGuiIO& io = ImGui::GetIO(bd->Context);
647 io.AddMouseWheelEvent(wheel_x, wheel_y);
648 //IMGUI_DEBUG_LOG("[Emsc] mode %d dx: %.2f, dy: %.2f, dz: %.2f --> feed %.2f %.2f\n", (int)ev->deltaMode, ev->deltaX, ev->deltaY, ev->deltaZ, wheel_x, wheel_y);
649 return EM_TRUE;
650}
651#endif
652
653#ifdef _WIN32
654static LRESULT CALLBACK ImGui_ImplGlfw_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
655#endif
656
657void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window)
658{
659 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
660 IM_ASSERT(bd->InstalledCallbacks == false && "Callbacks already installed!");
661 IM_ASSERT(bd->Window == window);
662
663 bd->PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback(window, ImGui_ImplGlfw_WindowFocusCallback);
664 bd->PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback(window, ImGui_ImplGlfw_CursorEnterCallback);
665 bd->PrevUserCallbackCursorPos = glfwSetCursorPosCallback(window, ImGui_ImplGlfw_CursorPosCallback);
666 bd->PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
667 bd->PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
668 bd->PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
669 bd->PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
670 bd->PrevUserCallbackMonitor = glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
671 bd->InstalledCallbacks = true;
672}
673
674void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window)
675{
676 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
677 IM_ASSERT(bd->InstalledCallbacks == true && "Callbacks not installed!");
678 IM_ASSERT(bd->Window == window);
679
680 glfwSetWindowFocusCallback(window, bd->PrevUserCallbackWindowFocus);
681 glfwSetCursorEnterCallback(window, bd->PrevUserCallbackCursorEnter);
682 glfwSetCursorPosCallback(window, bd->PrevUserCallbackCursorPos);
683 glfwSetMouseButtonCallback(window, bd->PrevUserCallbackMousebutton);
684 glfwSetScrollCallback(window, bd->PrevUserCallbackScroll);
685 glfwSetKeyCallback(window, bd->PrevUserCallbackKey);
686 glfwSetCharCallback(window, bd->PrevUserCallbackChar);
687 glfwSetMonitorCallback(bd->PrevUserCallbackMonitor);
688 bd->InstalledCallbacks = false;
689 bd->PrevUserCallbackWindowFocus = nullptr;
690 bd->PrevUserCallbackCursorEnter = nullptr;
691 bd->PrevUserCallbackCursorPos = nullptr;
692 bd->PrevUserCallbackMousebutton = nullptr;
693 bd->PrevUserCallbackScroll = nullptr;
694 bd->PrevUserCallbackKey = nullptr;
695 bd->PrevUserCallbackChar = nullptr;
696 bd->PrevUserCallbackMonitor = nullptr;
697}
698
699// Set to 'true' to enable chaining installed callbacks for all windows (including secondary viewports created by backends or by user).
700// This is 'false' by default meaning we only chain callbacks for the main viewport.
701// We cannot set this to 'true' by default because user callbacks code may be not testing the 'window' parameter of their callback.
702// If you set this to 'true' your user callback code will need to make sure you are testing the 'window' parameter.
703void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows)
704{
705 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
706 bd->CallbacksChainForAllWindows = chain_for_all_windows;
707}
708
709#ifdef __EMSCRIPTEN__
710#if EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3 >= 34020240817
711void ImGui_ImplGlfw_EmscriptenOpenURL(const char* url) { if (url) emscripten::glfw3::OpenURL(url); }
712#else
713EM_JS(void, ImGui_ImplGlfw_EmscriptenOpenURL, (const char* url), { url = url ? UTF8ToString(url) : null; if (url) window.open(url, '_blank'); });
714#endif
715#endif
716
717static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, GlfwClientApi client_api)
718{
719 ImGuiIO& io = ImGui::GetIO();
720 IMGUI_CHECKVERSION();
721 IM_ASSERT(io.BackendPlatformUserData == nullptr && "Already initialized a platform backend!");
722 //printf("GLFW_VERSION: %d.%d.%d (%d)", GLFW_VERSION_MAJOR, GLFW_VERSION_MINOR, GLFW_VERSION_REVISION, GLFW_VERSION_COMBINED);
723
724 // Setup backend capabilities flags
725 ImGui_ImplGlfw_Data* bd = IM_NEW(ImGui_ImplGlfw_Data)();
726 snprintf(bd->BackendPlatformName, sizeof(bd->BackendPlatformName), "imgui_impl_glfw (%d)", GLFW_VERSION_COMBINED);
727 io.BackendPlatformUserData = (void*)bd;
728 io.BackendPlatformName = bd->BackendPlatformName;
729#if GLFW_HAS_CREATECURSOR
730 io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
731#endif
732 io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
733
734 bool has_viewports = false;
735#ifndef __EMSCRIPTEN__
736 has_viewports = true;
737#if GLFW_HAS_GETPLATFORM
738 if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
739 has_viewports = false;
740#endif
741 if (has_viewports)
742 io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
743#endif
744#if GLFW_HAS_MOUSE_PASSTHROUGH || GLFW_HAS_WINDOW_HOVERED
745 io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can call io.AddMouseViewportEvent() with correct data (optional)
746#endif
747
748 bd->Context = ImGui::GetCurrentContext();
749 bd->Window = window;
750 bd->Time = 0.0;
751 bd->IsWayland = ImGui_ImplGlfw_IsWayland();
752 ImGui_ImplGlfw_ContextMap_Add(window, bd->Context);
753
754 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
755#if GLFW_VERSION_COMBINED < 3300
756 platform_io.Platform_SetClipboardTextFn = [](ImGuiContext*, const char* text) { glfwSetClipboardString(ImGui_ImplGlfw_GetBackendData()->Window, text); };
757 platform_io.Platform_GetClipboardTextFn = [](ImGuiContext*) { return glfwGetClipboardString(ImGui_ImplGlfw_GetBackendData()->Window); };
758#else
759 platform_io.Platform_SetClipboardTextFn = [](ImGuiContext*, const char* text) { glfwSetClipboardString(nullptr, text); };
760 platform_io.Platform_GetClipboardTextFn = [](ImGuiContext*) { return glfwGetClipboardString(nullptr); };
761#endif
762
763#ifdef __EMSCRIPTEN__
764 platform_io.Platform_OpenInShellFn = [](ImGuiContext*, const char* url) { ImGui_ImplGlfw_EmscriptenOpenURL(url); return true; };
765#endif
766
767 // Create mouse cursors
768 // (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
769 // GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
770 // Missing cursors will return nullptr and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
771#if GLFW_HAS_CREATECURSOR
772 GLFWerrorfun prev_error_callback = glfwSetErrorCallback(nullptr);
773 bd->MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
774 bd->MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
775 bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
776 bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
777 bd->MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
778#if GLFW_HAS_NEW_CURSORS
779 bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
780 bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
781 bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
782 bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
783#else
784 bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
785 bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
786 bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
787 bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
788#endif
789 glfwSetErrorCallback(prev_error_callback);
790#endif
791#if GLFW_HAS_GETERROR && !defined(__EMSCRIPTEN__) // Eat errors (see #5908)
792 (void)glfwGetError(nullptr);
793#endif
794
795 // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
796 if (install_callbacks)
797 ImGui_ImplGlfw_InstallCallbacks(window);
798
799 // Update monitor a first time during init
800 // (note: monitor callback are broken in GLFW 3.2 and earlier, see github.com/glfw/glfw/issues/784)
801 ImGui_ImplGlfw_UpdateMonitors();
802 glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
803
804 // Set platform dependent data in viewport
805 ImGuiViewport* main_viewport = ImGui::GetMainViewport();
806 main_viewport->PlatformHandle = (void*)bd->Window;
807#ifdef _WIN32
808 main_viewport->PlatformHandleRaw = glfwGetWin32Window(bd->Window);
809#elif defined(__APPLE__)
810 main_viewport->PlatformHandleRaw = (void*)glfwGetCocoaWindow(bd->Window);
811#else
812 IM_UNUSED(main_viewport);
813#endif
814 if (has_viewports)
815 ImGui_ImplGlfw_InitMultiViewportSupport();
816
817 // Windows: register a WndProc hook so we can intercept some messages.
818#ifdef _WIN32
819 HWND hwnd = (HWND)main_viewport->PlatformHandleRaw;
820 ::SetPropA(hwnd, "IMGUI_BACKEND_DATA", bd);
821 bd->PrevWndProc = (WNDPROC)::GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
822 IM_ASSERT(bd->PrevWndProc != nullptr);
823 ::SetWindowLongPtrW((HWND)main_viewport->PlatformHandleRaw, GWLP_WNDPROC, (LONG_PTR)ImGui_ImplGlfw_WndProc);
824#endif
825
826#if GLFW_HAS_X11
827 if (!bd->IsWayland)
828 {
829 // Load X11 module dynamically. Copied from the way that GLFW does it in x11_init.c
830#if defined(__CYGWIN__)
831 const char* x11_module_path = "libX11-6.so";
832#elif defined(__OpenBSD__) || defined(__NetBSD__)
833 const char* x11_module_path = "libX11.so";
834#else
835 const char* x11_module_path = "libX11.so.6";
836#endif
837 bd->X11Module = dlopen(x11_module_path, RTLD_LAZY | RTLD_LOCAL);
838 bd->XInternAtom = (PFN_XInternAtom)dlsym(bd->X11Module, "XInternAtom");
839 bd->XChangeProperty = (PFN_XChangeProperty)dlsym(bd->X11Module, "XChangeProperty");
840 bd->XChangeWindowAttributes = (PFN_XChangeWindowAttributes)dlsym(bd->X11Module, "XChangeWindowAttributes");
841 bd->XFlush = (PFN_XFlush)dlsym(bd->X11Module, "XFlush");
842 IM_ASSERT(bd->XInternAtom != nullptr && bd->XChangeProperty != nullptr && bd->XChangeWindowAttributes != nullptr && bd->XFlush != nullptr);
843 }
844#endif
845
846 // Emscripten: the same application can run on various platforms, so we detect the Apple platform at runtime
847 // to override io.ConfigMacOSXBehaviors from its default (which is always false in Emscripten).
848#ifdef __EMSCRIPTEN__
849#if EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3 >= 34020240817
850 if (emscripten::glfw3::IsRuntimePlatformApple())
851 {
852 io.ConfigMacOSXBehaviors = true;
853
854 // Due to how the browser (poorly) handles the Meta Key, this line essentially disables repeats when used.
855 // This means that Meta + V only registers a single key-press, even if the keys are held.
856 // This is a compromise for dealing with this issue in ImGui since ImGui implements key repeat itself.
857 // See https://github.com/pongasoft/emscripten-glfw/blob/v3.4.0.20240817/docs/Usage.md#the-problem-of-the-super-key
858 emscripten::glfw3::SetSuperPlusKeyTimeouts(10, 10);
859 }
860#endif
861#endif
862
863 bd->ClientApi = client_api;
864 return true;
865}
866
867bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks)
868{
869 return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_OpenGL);
870}
871
872bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks)
873{
874 return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Vulkan);
875}
876
877bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks)
878{
879 return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Unknown);
880}
881
882void ImGui_ImplGlfw_Shutdown()
883{
884 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
885 IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
886
887 ImGuiIO& io = ImGui::GetIO();
888 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
889
890 ImGui_ImplGlfw_ShutdownMultiViewportSupport();
891 if (bd->InstalledCallbacks)
892 ImGui_ImplGlfw_RestoreCallbacks(bd->Window);
893#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
894 if (bd->CanvasSelector)
895 emscripten_set_wheel_callback(bd->CanvasSelector, nullptr, false, nullptr);
896#endif
897#if GLFW_HAS_CREATECURSOR
898 for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
899 glfwDestroyCursor(bd->MouseCursors[cursor_n]);
900#endif
901 // Windows: restore our WndProc hook
902#ifdef _WIN32
903 ImGuiViewport* main_viewport = ImGui::GetMainViewport();
904 ::SetPropA((HWND)main_viewport->PlatformHandleRaw, "IMGUI_BACKEND_DATA", nullptr);
905 ::SetWindowLongPtrW((HWND)main_viewport->PlatformHandleRaw, GWLP_WNDPROC, (LONG_PTR)bd->PrevWndProc);
906 bd->PrevWndProc = nullptr;
907#endif
908
909#if GLFW_HAS_X11
910 if (bd->X11Module != nullptr)
911 dlclose(bd->X11Module);
912#endif
913
914 io.BackendPlatformName = nullptr;
915 io.BackendPlatformUserData = nullptr;
916 io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_HasMouseHoveredViewport);
917 platform_io.ClearPlatformHandlers();
918 ImGui_ImplGlfw_ContextMap_Remove(bd->Window);
919 IM_DELETE(bd);
920}
921
922static void ImGui_ImplGlfw_UpdateMouseData()
923{
924 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
925 ImGuiIO& io = ImGui::GetIO();
926 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
927
928 ImGuiID mouse_viewport_id = 0;
929 const ImVec2 mouse_pos_prev = io.MousePos;
930 for (int n = 0; n < platform_io.Viewports.Size; n++)
931 {
932 ImGuiViewport* viewport = platform_io.Viewports[n];
933 GLFWwindow* window = (GLFWwindow*)viewport->PlatformHandle;
934
935#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
936 const bool is_window_focused = true;
937#else
938 const bool is_window_focused = glfwGetWindowAttrib(window, GLFW_FOCUSED) != 0;
939#endif
940 if (is_window_focused)
941 {
942 // (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when io.ConfigNavMoveSetMousePos is enabled by user)
943 // When multi-viewports are enabled, all Dear ImGui positions are same as OS positions.
944 if (io.WantSetMousePos)
945 glfwSetCursorPos(window, (double)(mouse_pos_prev.x - viewport->Pos.x), (double)(mouse_pos_prev.y - viewport->Pos.y));
946
947 // (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
948 if (bd->MouseWindow == nullptr)
949 {
950 double mouse_x, mouse_y;
951 glfwGetCursorPos(window, &mouse_x, &mouse_y);
952 if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
953 {
954 // Single viewport mode: mouse position in client window coordinates (io.MousePos is (0,0) when the mouse is on the upper-left corner of the app window)
955 // Multi-viewport mode: mouse position in OS absolute coordinates (io.MousePos is (0,0) when the mouse is on the upper-left of the primary monitor)
956 int window_x, window_y;
957 glfwGetWindowPos(window, &window_x, &window_y);
958 mouse_x += window_x;
959 mouse_y += window_y;
960 }
961 bd->LastValidMousePos = ImVec2((float)mouse_x, (float)mouse_y);
962 io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
963 }
964 }
965
966 // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
967 // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
968 // - [X] GLFW >= 3.3 backend ON WINDOWS ONLY does correctly ignore viewports with the _NoInputs flag (since we implement hit via our WndProc hook)
969 // On other platforms we rely on the library fallbacking to its own search when reporting a viewport with _NoInputs flag.
970 // - [!] GLFW <= 3.2 backend CANNOT correctly ignore viewports with the _NoInputs flag, and CANNOT reported Hovered Viewport because of mouse capture.
971 // Some backend are not able to handle that correctly. If a backend report an hovered viewport that has the _NoInputs flag (e.g. when dragging a window
972 // for docking, the viewport has the _NoInputs flag in order to allow us to find the viewport under), then Dear ImGui is forced to ignore the value reported
973 // by the backend, and use its flawed heuristic to guess the viewport behind.
974 // - [X] GLFW backend correctly reports this regardless of another viewport behind focused and dragged from (we need this to find a useful drag and drop target).
975 // FIXME: This is currently only correct on Win32. See what we do below with the WM_NCHITTEST, missing an equivalent for other systems.
976 // See https://github.com/glfw/glfw/issues/1236 if you want to help in making this a GLFW feature.
977#if GLFW_HAS_MOUSE_PASSTHROUGH
978 const bool window_no_input = (viewport->Flags & ImGuiViewportFlags_NoInputs) != 0;
979 glfwSetWindowAttrib(window, GLFW_MOUSE_PASSTHROUGH, window_no_input);
980#endif
981#if GLFW_HAS_MOUSE_PASSTHROUGH || GLFW_HAS_WINDOW_HOVERED
982 if (glfwGetWindowAttrib(window, GLFW_HOVERED))
983 mouse_viewport_id = viewport->ID;
984#else
985 // We cannot use bd->MouseWindow maintained from CursorEnter/Leave callbacks, because it is locked to the window capturing mouse.
986#endif
987 }
988
989 if (io.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
990 io.AddMouseViewportEvent(mouse_viewport_id);
991}
992
993static void ImGui_ImplGlfw_UpdateMouseCursor()
994{
995 ImGuiIO& io = ImGui::GetIO();
996 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
997 if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(bd->Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
998 {
999 bd->LastMouseCursor = nullptr; // Invalidate so that if user changes underlying cursor we will update it next time we can.
1000 return;
1001 }
1002
1003 ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
1004 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
1005 for (int n = 0; n < platform_io.Viewports.Size; n++)
1006 {
1007 GLFWwindow* window = (GLFWwindow*)platform_io.Viewports[n]->PlatformHandle;
1008 if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
1009 {
1010 if (bd->LastMouseCursor != nullptr)
1011 {
1012 // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
1013 glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
1014 bd->LastMouseCursor = nullptr;
1015 }
1016 }
1017 else
1018 {
1019 // Show OS mouse cursor
1020 // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
1021#if GLFW_HAS_CREATECURSOR
1022 GLFWcursor* cursor = bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow];
1023 if (bd->LastMouseCursor != cursor)
1024 {
1025 glfwSetCursor(window, cursor);
1026 bd->LastMouseCursor = cursor;
1027 }
1028#endif
1029 glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
1030 }
1031 }
1032}
1033
1034// Update gamepad inputs
1035static inline float Saturate(float v) { return v < 0.0f ? 0.0f : v > 1.0f ? 1.0f : v; }
1036static void ImGui_ImplGlfw_UpdateGamepads()
1037{
1038 ImGuiIO& io = ImGui::GetIO();
1039 if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0) // FIXME: Technically feeding gamepad shouldn't depend on this now that they are regular inputs, but see #8075
1040 return;
1041
1042 io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
1043#if GLFW_HAS_GAMEPAD_API && !defined(EMSCRIPTEN_USE_EMBEDDED_GLFW3)
1044 GLFWgamepadstate gamepad;
1045 if (!glfwGetGamepadState(GLFW_JOYSTICK_1, &gamepad))
1046 return;
1047 #define MAP_BUTTON(KEY_NO, BUTTON_NO, _UNUSED) do { io.AddKeyEvent(KEY_NO, gamepad.buttons[BUTTON_NO] != 0); } while (0)
1048 #define MAP_ANALOG(KEY_NO, AXIS_NO, _UNUSED, V0, V1) do { float v = gamepad.axes[AXIS_NO]; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
1049#else
1050 int axes_count = 0, buttons_count = 0;
1051 const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
1052 const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
1053 if (axes_count == 0 || buttons_count == 0)
1054 return;
1055 #define MAP_BUTTON(KEY_NO, _UNUSED, BUTTON_NO) do { io.AddKeyEvent(KEY_NO, (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS)); } while (0)
1056 #define MAP_ANALOG(KEY_NO, _UNUSED, AXIS_NO, V0, V1) do { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
1057#endif
1058 io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
1059 MAP_BUTTON(ImGuiKey_GamepadStart, GLFW_GAMEPAD_BUTTON_START, 7);
1060 MAP_BUTTON(ImGuiKey_GamepadBack, GLFW_GAMEPAD_BUTTON_BACK, 6);
1061 MAP_BUTTON(ImGuiKey_GamepadFaceLeft, GLFW_GAMEPAD_BUTTON_X, 2); // Xbox X, PS Square
1062 MAP_BUTTON(ImGuiKey_GamepadFaceRight, GLFW_GAMEPAD_BUTTON_B, 1); // Xbox B, PS Circle
1063 MAP_BUTTON(ImGuiKey_GamepadFaceUp, GLFW_GAMEPAD_BUTTON_Y, 3); // Xbox Y, PS Triangle
1064 MAP_BUTTON(ImGuiKey_GamepadFaceDown, GLFW_GAMEPAD_BUTTON_A, 0); // Xbox A, PS Cross
1065 MAP_BUTTON(ImGuiKey_GamepadDpadLeft, GLFW_GAMEPAD_BUTTON_DPAD_LEFT, 13);
1066 MAP_BUTTON(ImGuiKey_GamepadDpadRight, GLFW_GAMEPAD_BUTTON_DPAD_RIGHT, 11);
1067 MAP_BUTTON(ImGuiKey_GamepadDpadUp, GLFW_GAMEPAD_BUTTON_DPAD_UP, 10);
1068 MAP_BUTTON(ImGuiKey_GamepadDpadDown, GLFW_GAMEPAD_BUTTON_DPAD_DOWN, 12);
1069 MAP_BUTTON(ImGuiKey_GamepadL1, GLFW_GAMEPAD_BUTTON_LEFT_BUMPER, 4);
1070 MAP_BUTTON(ImGuiKey_GamepadR1, GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER, 5);
1071 MAP_ANALOG(ImGuiKey_GamepadL2, GLFW_GAMEPAD_AXIS_LEFT_TRIGGER, 4, -0.75f, +1.0f);
1072 MAP_ANALOG(ImGuiKey_GamepadR2, GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER, 5, -0.75f, +1.0f);
1073 MAP_BUTTON(ImGuiKey_GamepadL3, GLFW_GAMEPAD_BUTTON_LEFT_THUMB, 8);
1074 MAP_BUTTON(ImGuiKey_GamepadR3, GLFW_GAMEPAD_BUTTON_RIGHT_THUMB, 9);
1075 MAP_ANALOG(ImGuiKey_GamepadLStickLeft, GLFW_GAMEPAD_AXIS_LEFT_X, 0, -0.25f, -1.0f);
1076 MAP_ANALOG(ImGuiKey_GamepadLStickRight, GLFW_GAMEPAD_AXIS_LEFT_X, 0, +0.25f, +1.0f);
1077 MAP_ANALOG(ImGuiKey_GamepadLStickUp, GLFW_GAMEPAD_AXIS_LEFT_Y, 1, -0.25f, -1.0f);
1078 MAP_ANALOG(ImGuiKey_GamepadLStickDown, GLFW_GAMEPAD_AXIS_LEFT_Y, 1, +0.25f, +1.0f);
1079 MAP_ANALOG(ImGuiKey_GamepadRStickLeft, GLFW_GAMEPAD_AXIS_RIGHT_X, 2, -0.25f, -1.0f);
1080 MAP_ANALOG(ImGuiKey_GamepadRStickRight, GLFW_GAMEPAD_AXIS_RIGHT_X, 2, +0.25f, +1.0f);
1081 MAP_ANALOG(ImGuiKey_GamepadRStickUp, GLFW_GAMEPAD_AXIS_RIGHT_Y, 3, -0.25f, -1.0f);
1082 MAP_ANALOG(ImGuiKey_GamepadRStickDown, GLFW_GAMEPAD_AXIS_RIGHT_Y, 3, +0.25f, +1.0f);
1083 #undef MAP_BUTTON
1084 #undef MAP_ANALOG
1085}
1086
1087static void ImGui_ImplGlfw_UpdateMonitors()
1088{
1089 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
1090 int monitors_count = 0;
1091 GLFWmonitor** glfw_monitors = glfwGetMonitors(&monitors_count);
1092
1093 bool updated_monitors = false;
1094 for (int n = 0; n < monitors_count; n++)
1095 {
1096 ImGuiPlatformMonitor monitor;
1097 int x, y;
1098 glfwGetMonitorPos(glfw_monitors[n], &x, &y);
1099 const GLFWvidmode* vid_mode = glfwGetVideoMode(glfw_monitors[n]);
1100 if (vid_mode == nullptr)
1101 continue; // Failed to get Video mode (e.g. Emscripten does not support this function)
1102 if (vid_mode->width <= 0 || vid_mode->height <= 0)
1103 continue; // Failed to query suitable monitor info (#9195)
1104 monitor.MainPos = monitor.WorkPos = ImVec2((float)x, (float)y);
1105 monitor.MainSize = monitor.WorkSize = ImVec2((float)vid_mode->width, (float)vid_mode->height);
1106#if GLFW_HAS_MONITOR_WORK_AREA
1107 int w, h;
1108 glfwGetMonitorWorkarea(glfw_monitors[n], &x, &y, &w, &h);
1109 if (w > 0 && h > 0) // Workaround a small GLFW issue reporting zero on monitor changes: https://github.com/glfw/glfw/pull/1761
1110 {
1111 monitor.WorkPos = ImVec2((float)x, (float)y);
1112 monitor.WorkSize = ImVec2((float)w, (float)h);
1113 }
1114#endif
1115 float scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfw_monitors[n]);
1116 if (scale == 0.0f)
1117 continue; // Some accessibility applications are declaring virtual monitors with a DPI of 0 (#7902)
1118 monitor.DpiScale = scale;
1119 monitor.PlatformHandle = (void*)glfw_monitors[n]; // [...] GLFW doc states: "guaranteed to be valid only until the monitor configuration changes"
1120
1121 // Preserve existing monitor list until a valid one is added.
1122 // Happens on macOS sleeping (#5683) and seemingly occasionally on Windows (#9195)
1123 if (!updated_monitors)
1124 platform_io.Monitors.resize(0);
1125 updated_monitors = true;
1126 platform_io.Monitors.push_back(monitor);
1127 }
1128}
1129
1130// For GFLW 3.2 + Windows: include a simplified non-monitor aware version of ImGui_ImplWin32_GetDpiScaleForMonitor().
1131// This is merely a band-aid to make using GLFW 3.2 a little bit nicer, but prefer to use GLFW 3.3+ or the full correct functions from the Win32 backend.
1132#if !GLFW_HAS_PER_MONITOR_DPI && defined(_WIN32) && !defined(NOGDI)
1133static float ImGui_ImplWin32_GetLegacyDpiScale() { const HDC dc = ::GetDC(nullptr); UINT xdpi = ::GetDeviceCaps(dc, LOGPIXELSX); ::ReleaseDC(nullptr, dc); return (float)xdpi / 96.0f; }
1134static void glfwGetWindowContentScale(GLFWwindow*, float* x_scale, float* y_scale) { *x_scale = *y_scale = ImGui_ImplWin32_GetLegacyDpiScale(); }
1135static void glfwGetMonitorContentScale(GLFWmonitor*, float* x_scale, float* y_scale) { *x_scale = *y_scale = ImGui_ImplWin32_GetLegacyDpiScale(); }
1136#undef GLFW_HAS_PER_MONITOR_DPI
1137#define GLFW_HAS_PER_MONITOR_DPI 1
1138#endif
1139
1140// - On Windows the process needs to be marked DPI-aware!! SDL2 doesn't do it by default. You can call ::SetProcessDPIAware() or call ImGui_ImplWin32_EnableDpiAwareness() from Win32 backend.
1141// - Apple platforms use FramebufferScale so we always return 1.0f.
1142// - Some accessibility applications are declaring virtual monitors with a DPI of 0.0f, see #7902. We preserve this value for caller to handle.
1143float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window)
1144{
1145#if GLFW_HAS_WAYLAND
1146 if (ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window))
1147 if (bd->IsWayland)
1148 return 1.0f;
1149#endif
1150#if GLFW_HAS_PER_MONITOR_DPI && !(defined(__APPLE__) || defined(__EMSCRIPTEN__) || defined(__ANDROID__))
1151 float x_scale, y_scale;
1152 glfwGetWindowContentScale(window, &x_scale, &y_scale);
1153 return x_scale;
1154#else
1155 IM_UNUSED(window);
1156 return 1.0f;
1157#endif
1158}
1159
1160float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor)
1161{
1162#if GLFW_HAS_WAYLAND
1163 if (ImGui_ImplGlfw_IsWayland()) // We can't access our bd->IsWayland cache for a monitor.
1164 return 1.0f;
1165#endif
1166#if GLFW_HAS_PER_MONITOR_DPI && !(defined(__APPLE__) || defined(__EMSCRIPTEN__) || defined(__ANDROID__))
1167 float x_scale, y_scale;
1168 glfwGetMonitorContentScale(monitor, &x_scale, &y_scale);
1169 return x_scale;
1170#else
1171 IM_UNUSED(monitor);
1172 return 1.0f;
1173#endif
1174}
1175
1176static void ImGui_ImplGlfw_GetWindowSizeAndFramebufferScale(GLFWwindow* window, ImVec2* out_size, ImVec2* out_framebuffer_scale)
1177{
1178 int w, h;
1179 int display_w, display_h;
1180 glfwGetWindowSize(window, &w, &h);
1181 glfwGetFramebufferSize(window, &display_w, &display_h);
1182 float fb_scale_x = (w > 0) ? (float)display_w / (float)w : 1.0f;
1183 float fb_scale_y = (h > 0) ? (float)display_h / (float)h : 1.0f;
1184#if GLFW_HAS_WAYLAND
1185 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData(window);
1186 if (!bd->IsWayland)
1187 fb_scale_x = fb_scale_y = 1.0f;
1188#endif
1189 if (out_size != nullptr)
1190 *out_size = ImVec2((float)w, (float)h);
1191 if (out_framebuffer_scale != nullptr)
1192 *out_framebuffer_scale = ImVec2(fb_scale_x, fb_scale_y);
1193}
1194
1195void ImGui_ImplGlfw_NewFrame()
1196{
1197 ImGuiIO& io = ImGui::GetIO();
1198 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1199 IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplGlfw_InitForXXX()?");
1200
1201 // Setup main viewport size (every frame to accommodate for window resizing)
1202 ImGui_ImplGlfw_GetWindowSizeAndFramebufferScale(bd->Window, &io.DisplaySize, &io.DisplayFramebufferScale);
1203 ImGui_ImplGlfw_UpdateMonitors();
1204
1205 // Setup time step
1206 // (Accept glfwGetTime() not returning a monotonically increasing value. Seems to happens on disconnecting peripherals and probably on VMs and Emscripten, see #6491, #6189, #6114, #3644)
1207 double current_time = glfwGetTime();
1208 if (current_time <= bd->Time)
1209 current_time = bd->Time + 0.00001;
1210 io.DeltaTime = bd->Time > 0.0 ? (float)(current_time - bd->Time) : (float)(1.0f / 60.0f);
1211 bd->Time = current_time;
1212
1213 bd->MouseIgnoreButtonUp = false;
1214 ImGui_ImplGlfw_UpdateMouseData();
1215 ImGui_ImplGlfw_UpdateMouseCursor();
1216
1217 // Update game controllers (if enabled and available)
1218 ImGui_ImplGlfw_UpdateGamepads();
1219}
1220
1221// GLFW doesn't provide a portable sleep function
1222void ImGui_ImplGlfw_Sleep(int milliseconds)
1223{
1224#ifdef _WIN32
1225 ::Sleep(milliseconds);
1226#else
1227 usleep(milliseconds * 1000);
1228#endif
1229}
1230
1231#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
1232static EM_BOOL ImGui_ImplGlfw_OnCanvasSizeChange(int event_type, const EmscriptenUiEvent* event, void* user_data)
1233{
1234 ImGui_ImplGlfw_Data* bd = (ImGui_ImplGlfw_Data*)user_data;
1235 double canvas_width, canvas_height;
1236 emscripten_get_element_css_size(bd->CanvasSelector, &canvas_width, &canvas_height);
1237 glfwSetWindowSize(bd->Window, (int)canvas_width, (int)canvas_height);
1238 return true;
1239}
1240
1241static EM_BOOL ImGui_ImplEmscripten_FullscreenChangeCallback(int event_type, const EmscriptenFullscreenChangeEvent* event, void* user_data)
1242{
1243 ImGui_ImplGlfw_Data* bd = (ImGui_ImplGlfw_Data*)user_data;
1244 double canvas_width, canvas_height;
1245 emscripten_get_element_css_size(bd->CanvasSelector, &canvas_width, &canvas_height);
1246 glfwSetWindowSize(bd->Window, (int)canvas_width, (int)canvas_height);
1247 return true;
1248}
1249
1250// 'canvas_selector' is a CSS selector. The event listener is applied to the first element that matches the query.
1251// STRING MUST PERSIST FOR THE APPLICATION DURATION. PLEASE USE A STRING LITERAL OR ENSURE POINTER WILL STAY VALID.
1252void ImGui_ImplGlfw_InstallEmscriptenCallbacks(GLFWwindow*, const char* canvas_selector)
1253{
1254 IM_ASSERT(canvas_selector != nullptr);
1255 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1256 IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplGlfw_InitForXXX()?");
1257
1258 bd->CanvasSelector = canvas_selector;
1259 emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, bd, false, ImGui_ImplGlfw_OnCanvasSizeChange);
1260 emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, bd, false, ImGui_ImplEmscripten_FullscreenChangeCallback);
1261
1262 // Change the size of the GLFW window according to the size of the canvas
1263 ImGui_ImplGlfw_OnCanvasSizeChange(EMSCRIPTEN_EVENT_RESIZE, {}, bd);
1264
1265 // Register Emscripten Wheel callback to workaround issue in Emscripten GLFW Emulation (#6096)
1266 // We intentionally do not check 'if (install_callbacks)' here, as some users may set it to false and call GLFW callback themselves.
1267 // FIXME: May break chaining in case user registered their own Emscripten callback?
1268 emscripten_set_wheel_callback(bd->CanvasSelector, bd, false, ImGui_ImplEmscripten_WheelCallback);
1269}
1270#elif defined(EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3)
1271// When using --use-port=contrib.glfw3 for the GLFW implementation, you can override the behavior of this call
1272// by invoking emscripten_glfw_make_canvas_resizable afterward.
1273// See https://github.com/pongasoft/emscripten-glfw/blob/master/docs/Usage.md#how-to-make-the-canvas-resizable-by-the-user for an explanation
1274void ImGui_ImplGlfw_InstallEmscriptenCallbacks(GLFWwindow* window, const char* canvas_selector)
1275{
1276 GLFWwindow* w = (GLFWwindow*)(EM_ASM_INT({ return Module.glfwGetWindow(UTF8ToString($0)); }, canvas_selector));
1277 IM_ASSERT(window == w); // Sanity check
1278 IM_UNUSED(w);
1279 emscripten_glfw_make_canvas_resizable(window, "window", nullptr);
1280}
1281#endif // #ifdef EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3
1282
1283
1284//--------------------------------------------------------------------------------------------------------
1285// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
1286// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
1287// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
1288//--------------------------------------------------------------------------------------------------------
1289
1290// Helper structure we store in the void* PlatformUserData field of each ImGuiViewport to easily retrieve our backend data.
1291struct ImGui_ImplGlfw_ViewportData
1292{
1293 GLFWwindow* Window; // Stored in ImGuiViewport::PlatformHandle
1294 bool WindowOwned;
1295 int IgnoreWindowPosEventFrame;
1296 int IgnoreWindowSizeEventFrame;
1297#ifdef _WIN32
1298 WNDPROC PrevWndProc;
1299#endif
1300
1301 ImGui_ImplGlfw_ViewportData() { memset((void*)this, 0, sizeof(*this)); IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; }
1302 ~ImGui_ImplGlfw_ViewportData() { IM_ASSERT(Window == nullptr); }
1303};
1304
1305static void ImGui_ImplGlfw_WindowCloseCallback(GLFWwindow* window)
1306{
1307 if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
1308 viewport->PlatformRequestClose = true;
1309}
1310
1311// GLFW may dispatch window pos/size events after calling glfwSetWindowPos()/glfwSetWindowSize().
1312// However: depending on the platform the callback may be invoked at different time:
1313// - on Windows it appears to be called within the glfwSetWindowPos()/glfwSetWindowSize() call
1314// - on Linux it is queued and invoked during glfwPollEvents()
1315// Because the event doesn't always fire on glfwSetWindowXXX() we use a frame counter tag to only
1316// ignore recent glfwSetWindowXXX() calls.
1317static void ImGui_ImplGlfw_WindowPosCallback(GLFWwindow* window, int, int)
1318{
1319 if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
1320 {
1321 if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
1322 {
1323 bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowPosEventFrame + 1);
1324 //data->IgnoreWindowPosEventFrame = -1;
1325 if (ignore_event)
1326 return;
1327 }
1328 viewport->PlatformRequestMove = true;
1329 }
1330}
1331
1332static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int)
1333{
1334 if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
1335 {
1336 if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
1337 {
1338 bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowSizeEventFrame + 1);
1339 //data->IgnoreWindowSizeEventFrame = -1;
1340 if (ignore_event)
1341 return;
1342 }
1343 viewport->PlatformRequestResize = true;
1344 }
1345}
1346
1347#if !defined(__APPLE__) && !defined(_WIN32) && !defined(__EMSCRIPTEN__) && GLFW_HAS_GETPLATFORM
1348#define IMGUI_GLFW_HAS_SETWINDOWFLOATING
1349static void ImGui_ImplGlfw_SetWindowFloating(ImGui_ImplGlfw_Data* bd, GLFWwindow* window)
1350{
1351#ifdef GLFW_EXPOSE_NATIVE_X11
1352 if (glfwGetPlatform() == GLFW_PLATFORM_X11)
1353 {
1354 Display* display = glfwGetX11Display();
1355 Window xwindow = glfwGetX11Window(window);
1356 Atom wm_type = bd->XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
1357 Atom wm_type_dialog = bd->XInternAtom(display, "_NET_WM_WINDOW_TYPE_DIALOG", False);
1358 bd->XChangeProperty(display, xwindow, wm_type, XA_ATOM, 32, PropModeReplace, (unsigned char*)&wm_type_dialog, 1);
1359 XSetWindowAttributes attrs;
1360 attrs.override_redirect = False;
1361 bd->XChangeWindowAttributes(display, xwindow, CWOverrideRedirect, &attrs);
1362 bd->XFlush(display);
1363 }
1364#endif // GLFW_EXPOSE_NATIVE_X11
1365#ifdef GLFW_EXPOSE_NATIVE_WAYLAND
1366 // FIXME: Help needed, see #8884, #8474 for discussions about this.
1367#endif // GLFW_EXPOSE_NATIVE_X11
1368}
1369#endif // IMGUI_GLFW_HAS_SETWINDOWFLOATING
1370
1371static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport)
1372{
1373 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1374 ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
1375 viewport->PlatformUserData = vd;
1376
1377 // Workaround for Linux: ignore mouse up events corresponding to losing focus of the previously focused window (#7733, #3158, #7922)
1378#ifdef __linux__
1379 bd->MouseIgnoreButtonUpWaitForFocusLoss = true;
1380#endif
1381
1382 // GLFW 3.2 unfortunately always set focus on glfwCreateWindow() if GLFW_VISIBLE is set, regardless of GLFW_FOCUSED
1383 // With GLFW 3.3, the hint GLFW_FOCUS_ON_SHOW fixes this problem
1384 glfwWindowHint(GLFW_VISIBLE, false);
1385 glfwWindowHint(GLFW_FOCUSED, false);
1386#if GLFW_HAS_FOCUS_ON_SHOW
1387 glfwWindowHint(GLFW_FOCUS_ON_SHOW, false);
1388#endif
1389 glfwWindowHint(GLFW_DECORATED, (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? false : true);
1390#if GLFW_HAS_WINDOW_TOPMOST
1391 glfwWindowHint(GLFW_FLOATING, (viewport->Flags & ImGuiViewportFlags_TopMost) ? true : false);
1392#endif
1393 GLFWwindow* share_window = (bd->ClientApi == GlfwClientApi_OpenGL) ? bd->Window : nullptr;
1394 vd->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", nullptr, share_window);
1395 vd->WindowOwned = true;
1396 ImGui_ImplGlfw_ContextMap_Add(vd->Window, bd->Context);
1397 viewport->PlatformHandle = (void*)vd->Window;
1398#ifdef IMGUI_GLFW_HAS_SETWINDOWFLOATING
1399 ImGui_ImplGlfw_SetWindowFloating(bd, vd->Window);
1400#endif
1401#ifdef _WIN32
1402 viewport->PlatformHandleRaw = glfwGetWin32Window(vd->Window);
1403 ::SetPropA((HWND)viewport->PlatformHandleRaw, "IMGUI_BACKEND_DATA", bd);
1404#elif defined(__APPLE__)
1405 viewport->PlatformHandleRaw = (void*)glfwGetCocoaWindow(vd->Window);
1406#endif
1407 glfwSetWindowPos(vd->Window, (int)viewport->Pos.x, (int)viewport->Pos.y);
1408
1409 // Install GLFW callbacks for secondary viewports
1410 glfwSetWindowFocusCallback(vd->Window, ImGui_ImplGlfw_WindowFocusCallback);
1411 glfwSetCursorEnterCallback(vd->Window, ImGui_ImplGlfw_CursorEnterCallback);
1412 glfwSetCursorPosCallback(vd->Window, ImGui_ImplGlfw_CursorPosCallback);
1413 glfwSetMouseButtonCallback(vd->Window, ImGui_ImplGlfw_MouseButtonCallback);
1414 glfwSetScrollCallback(vd->Window, ImGui_ImplGlfw_ScrollCallback);
1415 glfwSetKeyCallback(vd->Window, ImGui_ImplGlfw_KeyCallback);
1416 glfwSetCharCallback(vd->Window, ImGui_ImplGlfw_CharCallback);
1417 glfwSetWindowCloseCallback(vd->Window, ImGui_ImplGlfw_WindowCloseCallback);
1418 glfwSetWindowPosCallback(vd->Window, ImGui_ImplGlfw_WindowPosCallback);
1419 glfwSetWindowSizeCallback(vd->Window, ImGui_ImplGlfw_WindowSizeCallback);
1420 if (bd->ClientApi == GlfwClientApi_OpenGL)
1421 {
1422 glfwMakeContextCurrent(vd->Window);
1423 glfwSwapInterval(0);
1424 }
1425}
1426
1427static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport)
1428{
1429 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1430 if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
1431 {
1432 if (vd->WindowOwned)
1433 {
1434#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
1435 HWND hwnd = (HWND)viewport->PlatformHandleRaw;
1436 ::RemovePropA(hwnd, "IMGUI_VIEWPORT");
1437#endif
1438
1439 // Release any keys that were pressed in the window being destroyed and are still held down,
1440 // because we will not receive any release events after window is destroyed.
1441 for (int i = 0; i < IM_COUNTOF(bd->KeyOwnerWindows); i++)
1442 if (bd->KeyOwnerWindows[i] == vd->Window)
1443 ImGui_ImplGlfw_KeyCallback(vd->Window, i, 0, GLFW_RELEASE, 0); // Later params are only used for main viewport, on which this function is never called.
1444
1445 ImGui_ImplGlfw_ContextMap_Remove(vd->Window);
1446 glfwDestroyWindow(vd->Window);
1447 }
1448 vd->Window = nullptr;
1449 IM_DELETE(vd);
1450 }
1451 viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
1452}
1453
1454static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport)
1455{
1456 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1457
1458#if defined(_WIN32)
1459 // GLFW hack: Hide icon from task bar
1460 HWND hwnd = (HWND)viewport->PlatformHandleRaw;
1461 if (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon)
1462 {
1463 LONG ex_style = ::GetWindowLong(hwnd, GWL_EXSTYLE);
1464 ex_style &= ~WS_EX_APPWINDOW;
1465 ex_style |= WS_EX_TOOLWINDOW;
1466 ::SetWindowLong(hwnd, GWL_EXSTYLE, ex_style);
1467 }
1468
1469 // GLFW hack: install WndProc for mouse source event and WM_NCHITTEST message handler.
1470 ::SetPropA(hwnd, "IMGUI_VIEWPORT", viewport);
1471 vd->PrevWndProc = (WNDPROC)::GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
1472 ::SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)ImGui_ImplGlfw_WndProc);
1473
1474#if !GLFW_HAS_FOCUS_ON_SHOW
1475 // GLFW hack: GLFW 3.2 has a bug where glfwShowWindow() also activates/focus the window.
1476 // The fix was pushed to GLFW repository on 2018/01/09 and should be included in GLFW 3.3 via a GLFW_FOCUS_ON_SHOW window attribute.
1477 // See https://github.com/glfw/glfw/issues/1189
1478 // FIXME-VIEWPORT: Implement same work-around for Linux/OSX in the meanwhile.
1479 if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
1480 {
1481 ::ShowWindow(hwnd, SW_SHOWNA);
1482 return;
1483 }
1484#endif
1485#endif
1486
1487 glfwShowWindow(vd->Window);
1488}
1489
1490static ImVec2 ImGui_ImplGlfw_GetWindowPos(ImGuiViewport* viewport)
1491{
1492 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1493 int x = 0, y = 0;
1494 glfwGetWindowPos(vd->Window, &x, &y);
1495 return ImVec2((float)x, (float)y);
1496}
1497
1498static void ImGui_ImplGlfw_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
1499{
1500 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1501 vd->IgnoreWindowPosEventFrame = ImGui::GetFrameCount();
1502 glfwSetWindowPos(vd->Window, (int)pos.x, (int)pos.y);
1503}
1504
1505static ImVec2 ImGui_ImplGlfw_GetWindowSize(ImGuiViewport* viewport)
1506{
1507 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1508 int w = 0, h = 0;
1509 glfwGetWindowSize(vd->Window, &w, &h);
1510 return ImVec2((float)w, (float)h);
1511}
1512
1513static void ImGui_ImplGlfw_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
1514{
1515 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1516#if defined(__APPLE__) && !GLFW_HAS_OSX_WINDOW_POS_FIX
1517 // Native OS windows are positioned from the bottom-left corner on macOS, whereas on other platforms they are
1518 // positioned from the upper-left corner. GLFW makes an effort to convert macOS style coordinates, however it
1519 // doesn't handle it when changing size. We are manually moving the window in order for changes of size to be based
1520 // on the upper-left corner.
1521 int x, y, width, height;
1522 glfwGetWindowPos(vd->Window, &x, &y);
1523 glfwGetWindowSize(vd->Window, &width, &height);
1524 glfwSetWindowPos(vd->Window, x, y - height + size.y);
1525#endif
1526 vd->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount();
1527 glfwSetWindowSize(vd->Window, (int)size.x, (int)size.y);
1528}
1529
1530static ImVec2 ImGui_ImplGlfw_GetWindowFramebufferScale(ImGuiViewport* viewport)
1531{
1532 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1533 ImVec2 framebuffer_scale;
1534 ImGui_ImplGlfw_GetWindowSizeAndFramebufferScale(vd->Window, nullptr, &framebuffer_scale);
1535 return framebuffer_scale;
1536}
1537
1538static void ImGui_ImplGlfw_SetWindowTitle(ImGuiViewport* viewport, const char* title)
1539{
1540 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1541 glfwSetWindowTitle(vd->Window, title);
1542}
1543
1544static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport)
1545{
1546#if GLFW_HAS_FOCUS_WINDOW
1547 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1548 glfwFocusWindow(vd->Window);
1549#else
1550 // FIXME: What are the effect of not having this function? At the moment imgui doesn't actually call SetWindowFocus - we set that up ahead, will answer that question later.
1551 (void)viewport;
1552#endif
1553}
1554
1555static bool ImGui_ImplGlfw_GetWindowFocus(ImGuiViewport* viewport)
1556{
1557 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1558 return glfwGetWindowAttrib(vd->Window, GLFW_FOCUSED) != 0;
1559}
1560
1561static bool ImGui_ImplGlfw_GetWindowMinimized(ImGuiViewport* viewport)
1562{
1563 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1564 return glfwGetWindowAttrib(vd->Window, GLFW_ICONIFIED) != 0;
1565}
1566
1567#if GLFW_HAS_WINDOW_ALPHA
1568static void ImGui_ImplGlfw_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
1569{
1570 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1571 glfwSetWindowOpacity(vd->Window, alpha);
1572}
1573#endif
1574
1575static void ImGui_ImplGlfw_RenderWindow(ImGuiViewport* viewport, void*)
1576{
1577 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1578 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1579 if (bd->ClientApi == GlfwClientApi_OpenGL)
1580 glfwMakeContextCurrent(vd->Window);
1581}
1582
1583static void ImGui_ImplGlfw_SwapBuffers(ImGuiViewport* viewport, void*)
1584{
1585 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1586 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1587 if (bd->ClientApi == GlfwClientApi_OpenGL)
1588 {
1589 glfwMakeContextCurrent(vd->Window);
1590 glfwSwapBuffers(vd->Window);
1591 }
1592}
1593
1594//--------------------------------------------------------------------------------------------------------
1595// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
1596//--------------------------------------------------------------------------------------------------------
1597
1598// Avoid including <vulkan.h> so we can build without it
1599#if GLFW_HAS_VULKAN
1600#ifndef VULKAN_H_
1601#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
1602#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
1603#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
1604#else
1605#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
1606#endif
1607VK_DEFINE_HANDLE(VkInstance)
1608VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
1609struct VkAllocationCallbacks;
1610enum VkResult { VK_RESULT_MAX_ENUM = 0x7FFFFFFF };
1611#endif // VULKAN_H_
1612extern "C" { extern GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); }
1613static int ImGui_ImplGlfw_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface)
1614{
1615 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1616 ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
1617 IM_UNUSED(bd);
1618 IM_ASSERT(bd->ClientApi == GlfwClientApi_Vulkan);
1619 VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, vd->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface);
1620 return (int)err;
1621}
1622#endif // GLFW_HAS_VULKAN
1623
1624static void ImGui_ImplGlfw_InitMultiViewportSupport()
1625{
1626 // Register platform interface (will be coupled with a renderer interface)
1627 ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
1628 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
1629 platform_io.Platform_CreateWindow = ImGui_ImplGlfw_CreateWindow;
1630 platform_io.Platform_DestroyWindow = ImGui_ImplGlfw_DestroyWindow;
1631 platform_io.Platform_ShowWindow = ImGui_ImplGlfw_ShowWindow;
1632 platform_io.Platform_SetWindowPos = ImGui_ImplGlfw_SetWindowPos;
1633 platform_io.Platform_GetWindowPos = ImGui_ImplGlfw_GetWindowPos;
1634 platform_io.Platform_SetWindowSize = ImGui_ImplGlfw_SetWindowSize;
1635 platform_io.Platform_GetWindowSize = ImGui_ImplGlfw_GetWindowSize;
1636 platform_io.Platform_GetWindowFramebufferScale = ImGui_ImplGlfw_GetWindowFramebufferScale;
1637 platform_io.Platform_SetWindowFocus = ImGui_ImplGlfw_SetWindowFocus;
1638 platform_io.Platform_GetWindowFocus = ImGui_ImplGlfw_GetWindowFocus;
1639 platform_io.Platform_GetWindowMinimized = ImGui_ImplGlfw_GetWindowMinimized;
1640 platform_io.Platform_SetWindowTitle = ImGui_ImplGlfw_SetWindowTitle;
1641 platform_io.Platform_RenderWindow = ImGui_ImplGlfw_RenderWindow;
1642 platform_io.Platform_SwapBuffers = ImGui_ImplGlfw_SwapBuffers;
1643#if GLFW_HAS_WINDOW_ALPHA
1644 platform_io.Platform_SetWindowAlpha = ImGui_ImplGlfw_SetWindowAlpha;
1645#endif
1646#if GLFW_HAS_VULKAN
1647 platform_io.Platform_CreateVkSurface = ImGui_ImplGlfw_CreateVkSurface;
1648#endif
1649
1650 // Register main window handle (which is owned by the main application, not by us)
1651 // This is mostly for simplicity and consistency, so that our code (e.g. mouse handling etc.) can use same logic for main and secondary viewports.
1652 ImGuiViewport* main_viewport = ImGui::GetMainViewport();
1653 ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
1654 vd->Window = bd->Window;
1655 vd->WindowOwned = false;
1656 main_viewport->PlatformUserData = vd;
1657 main_viewport->PlatformHandle = (void*)bd->Window;
1658}
1659
1660static void ImGui_ImplGlfw_ShutdownMultiViewportSupport()
1661{
1662 ImGui::DestroyPlatformWindows();
1663}
1664
1665//-----------------------------------------------------------------------------
1666
1667// WndProc hook (declared here because we will need access to ImGui_ImplGlfw_ViewportData)
1668#ifdef _WIN32
1669static ImGuiMouseSource GetMouseSourceFromMessageExtraInfo()
1670{
1671 LPARAM extra_info = ::GetMessageExtraInfo();
1672 if ((extra_info & 0xFFFFFF80) == 0xFF515700)
1673 return ImGuiMouseSource_Pen;
1674 if ((extra_info & 0xFFFFFF80) == 0xFF515780)
1675 return ImGuiMouseSource_TouchScreen;
1676 return ImGuiMouseSource_Mouse;
1677}
1678static LRESULT CALLBACK ImGui_ImplGlfw_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1679{
1680 ImGui_ImplGlfw_Data* bd = (ImGui_ImplGlfw_Data*)::GetPropA(hWnd, "IMGUI_BACKEND_DATA");
1681 ImGuiIO& io = ImGui::GetIO(bd->Context);
1682
1683 WNDPROC prev_wndproc = bd->PrevWndProc;
1684 ImGuiViewport* viewport = (ImGuiViewport*)::GetPropA(hWnd, "IMGUI_VIEWPORT");
1685 if (viewport != NULL)
1686 if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
1687 prev_wndproc = vd->PrevWndProc;
1688
1689 switch (msg)
1690 {
1691 // GLFW doesn't allow to distinguish Mouse vs TouchScreen vs Pen.
1692 // Add support for Win32 (based on imgui_impl_win32), because we rely on _TouchScreen info to trickle inputs differently.
1693 case WM_MOUSEMOVE: case WM_NCMOUSEMOVE:
1694 case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK: case WM_LBUTTONUP:
1695 case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK: case WM_RBUTTONUP:
1696 case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK: case WM_MBUTTONUP:
1697 case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK: case WM_XBUTTONUP:
1698 io.AddMouseSourceEvent(GetMouseSourceFromMessageExtraInfo());
1699 break;
1700
1701 // We have submitted https://github.com/glfw/glfw/pull/1568 to allow GLFW to support "transparent inputs".
1702 // In the meanwhile we implement custom per-platform workarounds here (FIXME-VIEWPORT: Implement same work-around for Linux/OSX!)
1703#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED
1704 case WM_NCHITTEST:
1705 {
1706 // Let mouse pass-through the window. This will allow the backend to call io.AddMouseViewportEvent() properly (which is OPTIONAL).
1707 // The ImGuiViewportFlags_NoInputs flag is set while dragging a viewport, as want to detect the window behind the one we are dragging.
1708 // If you cannot easily access those viewport flags from your windowing/event code: you may manually synchronize its state e.g. in
1709 // your main loop after calling UpdatePlatformWindows(). Iterate all viewports/platform windows and pass the flag to your windowing system.
1710 if (viewport && (viewport->Flags & ImGuiViewportFlags_NoInputs))
1711 return HTTRANSPARENT;
1712 break;
1713 }
1714#endif
1715 default: break;
1716 }
1717 return ::CallWindowProcW(prev_wndproc, hWnd, msg, wParam, lParam);
1718}
1719#endif // #ifdef _WIN32
1720
1721//-----------------------------------------------------------------------------
1722
1723#if defined(__clang__)
1724#pragma clang diagnostic pop
1725#endif
1726
1727#endif // #ifndef IMGUI_DISABLE