openMSX
imgui_impl_sdl2.cc
Go to the documentation of this file.
1// dear imgui: Platform Backend for SDL2
2// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
3// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
4// (Prefer SDL 2.0.5+ for full feature support.)
5
6// Implemented features:
7// [X] Platform: Clipboard support.
8// [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen.
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 SDL_SCANCODE_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
10// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
11// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
12// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
13// Issues:
14// [ ] Platform: Multi-viewport: Minimized windows seems to break mouse wheel events (at least under Windows).
15// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
16// [x] Platform: Basic IME support. App needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
17
18// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
19// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
20// Learn about Dear ImGui:
21// - FAQ https://dearimgui.com/faq
22// - Getting Started https://dearimgui.com/getting-started
23// - Documentation https://dearimgui.com/docs (same as your local docs/ folder).
24// - Introduction, links and more at the top of imgui.cpp
25
26// CHANGELOG
27// (minor and older changes stripped away, please see git history for details)
28// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
29// 2024-07-02: Emscripten: Added io.PlatformOpenInShellFn() handler for Emscripten versions.
30// 2024-07-02: Update for io.SetPlatformImeDataFn() -> io.PlatformSetImeDataFn() renaming in main library.
31// 2024-02-14: Inputs: Handle gamepad disconnection. Added ImGui_ImplSDL2_SetGamepadMode().
32// 2023-10-05: Inputs: Added support for extra ImGuiKey values: F13 to F24 function keys, app back/forward keys.
33// 2023-04-06: Inputs: Avoid calling SDL_StartTextInput()/SDL_StopTextInput() as they don't only pertain to IME. It's unclear exactly what their relation is to IME. (#6306)
34// 2023-04-04: Inputs: Added support for io.AddMouseSourceEvent() to discriminate ImGuiMouseSource_Mouse/ImGuiMouseSource_TouchScreen. (#2702)
35// 2023-02-23: Accept SDL_GetPerformanceCounter() not returning a monotonically increasing value. (#6189, #6114, #3644)
36// 2023-02-07: Implement IME handler (io.SetPlatformImeDataFn will call SDL_SetTextInputRect()/SDL_StartTextInput()).
37// 2023-02-07: *BREAKING CHANGE* Renamed this backend file from imgui_impl_sdl.cpp/.h to imgui_impl_sdl2.cpp/.h in prevision for the future release of SDL3.
38// 2023-02-02: Avoid calling SDL_SetCursor() when cursor has not changed, as the function is surprisingly costly on Mac with latest SDL (may be fixed in next SDL version).
39// 2023-02-02: Added support for SDL 2.0.18+ preciseX/preciseY mouse wheel data for smooth scrolling + Scaling X value on Emscripten (bug?). (#4019, #6096)
40// 2023-02-02: Removed SDL_MOUSEWHEEL value clamping, as values seem correct in latest Emscripten. (#4019)
41// 2023-02-01: Flipping SDL_MOUSEWHEEL 'wheel.x' value to match other backends and offer consistent horizontal scrolling direction. (#4019, #6096, #1463)
42// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
43// 2022-09-26: Inputs: Disable SDL 2.0.22 new "auto capture" (SDL_HINT_MOUSE_AUTO_CAPTURE) which prevents drag and drop across windows for multi-viewport support + don't capture when drag and dropping. (#5710)
44// 2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
45// 2022-03-22: Inputs: Fix mouse position issues when dragging outside of boundaries. SDL_CaptureMouse() erroneously still gives out LEAVE events when hovering OS decorations.
46// 2022-03-22: Inputs: Added support for extra mouse buttons (SDL_BUTTON_X1/SDL_BUTTON_X2).
47// 2022-02-04: Added SDL_Renderer* parameter to ImGui_ImplSDL2_InitForSDLRenderer(), so we can use SDL_GetRendererOutputSize() instead of SDL_GL_GetDrawableSize() when bound to a SDL_Renderer.
48// 2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
49// 2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
50// 2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
51// 2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
52// 2022-01-12: Update mouse inputs using SDL_MOUSEMOTION/SDL_WINDOWEVENT_LEAVE + fallback to provide it when focused but not hovered/captured. More standard and will allow us to pass it to future input queue API.
53// 2022-01-12: Maintain our own copy of MouseButtonsDown mask instead of using ImGui::IsAnyMouseDown() which will be obsoleted.
54// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
55// 2021-08-17: Calling io.AddFocusEvent() on SDL_WINDOWEVENT_FOCUS_GAINED/SDL_WINDOWEVENT_FOCUS_LOST.
56// 2021-07-29: Inputs: MousePos is correctly reported when the host platform window is hovered but not focused (using SDL_GetMouseFocus() + SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, requires SDL 2.0.5+)
57// 2021-06:29: *BREAKING CHANGE* Removed 'SDL_Window* window' parameter to ImGui_ImplSDL2_NewFrame() which was unnecessary.
58// 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).
59// 2021-03-22: Rework global mouse pos availability check listing supported platforms explicitly, effectively fixing mouse access on Raspberry Pi. (#2837, #3950)
60// 2020-05-25: Misc: Report a zero display-size when window is minimized, to be consistent with other backends.
61// 2020-02-20: Inputs: Fixed mapping for ImGuiKey_KeyPadEnter (using SDL_SCANCODE_KP_ENTER instead of SDL_SCANCODE_RETURN2).
62// 2019-12-17: Inputs: On Wayland, use SDL_GetMouseState (because there is no global mouse state).
63// 2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor.
64// 2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
65// 2019-04-23: Inputs: Added support for SDL_GameController (if ImGuiConfigFlags_NavEnableGamepad is set by user application).
66// 2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
67// 2018-12-21: Inputs: Workaround for Android/iOS which don't seem to handle focus related calls.
68// 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
69// 2018-11-14: Changed the signature of ImGui_ImplSDL2_ProcessEvent() to take a 'const SDL_Event*'.
70// 2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
71// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
72// 2018-06-08: Misc: Extracted imgui_impl_sdl.cpp/.h away from the old combined SDL2+OpenGL/Vulkan examples.
73// 2018-06-08: Misc: ImGui_ImplSDL2_InitForOpenGL() now takes a SDL_GLContext parameter.
74// 2018-05-09: Misc: Fixed clipboard paste memory leak (we didn't call SDL_FreeMemory on the data returned by SDL_GetClipboardText).
75// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
76// 2018-02-16: Inputs: Added support for mouse cursors, honoring ImGui::GetMouseCursor() value.
77// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
78// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
79// 2018-02-05: Misc: Using SDL_GetPerformanceCounter() instead of SDL_GetTicks() to be able to handle very high framerate (1000+ FPS).
80// 2018-02-05: Inputs: Keyboard mapping is using scancodes everywhere instead of a confusing mixture of keycodes and scancodes.
81// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
82// 2018-01-19: Inputs: When available (SDL 2.0.4+) using SDL_CaptureMouse() to retrieve coordinates outside of client area when dragging. Otherwise (SDL 2.0.3 and before) testing for SDL_WINDOW_INPUT_FOCUS instead of SDL_WINDOW_MOUSE_FOCUS.
83// 2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
84// 2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
85// 2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
86
87#include "imgui.h"
88#ifndef IMGUI_DISABLE
89#include "imgui_impl_sdl2.h"
90
91// Clang warnings with -Weverything
92#if defined(__clang__)
93#pragma clang diagnostic push
94#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision
95#endif
96
97// SDL
98// (the multi-viewports feature requires SDL features supported from SDL 2.0.4+. SDL 2.0.5+ is highly recommended)
99#include <SDL.h>
100#include <SDL_syswm.h>
101#ifdef __APPLE__
102#include <TargetConditionals.h>
103#endif
104#ifdef __EMSCRIPTEN__
105#include <emscripten/em_js.h>
106#endif
107
108#if SDL_VERSION_ATLEAST(2,0,4) && !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IOS) && !defined(__amigaos4__)
109#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE 1
110#else
111#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE 0
112#endif
113#define SDL_HAS_WINDOW_ALPHA SDL_VERSION_ATLEAST(2,0,5)
114#define SDL_HAS_ALWAYS_ON_TOP SDL_VERSION_ATLEAST(2,0,5)
115#define SDL_HAS_USABLE_DISPLAY_BOUNDS SDL_VERSION_ATLEAST(2,0,5)
116#define SDL_HAS_PER_MONITOR_DPI SDL_VERSION_ATLEAST(2,0,4)
117#define SDL_HAS_VULKAN SDL_VERSION_ATLEAST(2,0,6)
118#define SDL_HAS_DISPLAY_EVENT SDL_VERSION_ATLEAST(2,0,9)
119#if !SDL_HAS_VULKAN
120static const Uint32 SDL_WINDOW_VULKAN = 0x10000000;
121#endif
122
123// SDL Data
125{
126 SDL_Window* Window;
127 SDL_Renderer* Renderer;
128 Uint64 Time;
132
133 // Mouse handling
136 SDL_Cursor* MouseCursors[ImGuiMouseCursor_COUNT];
137 SDL_Cursor* MouseLastCursor;
140 bool MouseCanReportHoveredViewport; // This is hard to use/unreliable on SDL so we'll set ImGuiBackendFlags_HasMouseHoveredViewport dynamically based on state.
141
142 // Gamepad handling
143 ImVector<SDL_GameController*> Gamepads;
144 ImGui_ImplSDL2_GamepadMode GamepadMode;
146
147 ImGui_ImplSDL2_Data() { memset((void*)this, 0, sizeof(*this)); }
148};
149
150// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
151// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
152// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
153// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
154static ImGui_ImplSDL2_Data* ImGui_ImplSDL2_GetBackendData()
155{
156 return ImGui::GetCurrentContext() ? (ImGui_ImplSDL2_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
157}
158
159// Forward Declarations
160static void ImGui_ImplSDL2_UpdateMonitors();
161static void ImGui_ImplSDL2_InitPlatformInterface(SDL_Window* window, void* sdl_gl_context);
162static void ImGui_ImplSDL2_ShutdownPlatformInterface();
163
164// Functions
165static const char* ImGui_ImplSDL2_GetClipboardText(void*)
166{
167 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
168 if (bd->ClipboardTextData)
169 SDL_free(bd->ClipboardTextData);
170 bd->ClipboardTextData = SDL_GetClipboardText();
171 return bd->ClipboardTextData;
172}
173
174static void ImGui_ImplSDL2_SetClipboardText(void*, const char* text)
175{
176 SDL_SetClipboardText(text);
177}
178
179// Note: native IME will only display if user calls SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1") _before_ SDL_CreateWindow().
180static void ImGui_ImplSDL2_PlatformSetImeData(ImGuiContext*, ImGuiViewport* viewport, ImGuiPlatformImeData* data)
181{
182 if (data->WantVisible)
183 {
184 SDL_Rect r;
185 r.x = (int)(data->InputPos.x - viewport->Pos.x);
186 r.y = (int)(data->InputPos.y - viewport->Pos.y + data->InputLineHeight);
187 r.w = 1;
188 r.h = (int)data->InputLineHeight;
189 SDL_SetTextInputRect(&r);
190 }
191}
192
193static ImGuiKey ImGui_ImplSDL2_KeyEventToImGuiKey(SDL_Keycode keycode, SDL_Scancode scancode)
194{
195 IM_UNUSED(scancode);
196 switch (keycode)
197 {
198 case SDLK_TAB: return ImGuiKey_Tab;
199 case SDLK_LEFT: return ImGuiKey_LeftArrow;
200 case SDLK_RIGHT: return ImGuiKey_RightArrow;
201 case SDLK_UP: return ImGuiKey_UpArrow;
202 case SDLK_DOWN: return ImGuiKey_DownArrow;
203 case SDLK_PAGEUP: return ImGuiKey_PageUp;
204 case SDLK_PAGEDOWN: return ImGuiKey_PageDown;
205 case SDLK_HOME: return ImGuiKey_Home;
206 case SDLK_END: return ImGuiKey_End;
207 case SDLK_INSERT: return ImGuiKey_Insert;
208 case SDLK_DELETE: return ImGuiKey_Delete;
209 case SDLK_BACKSPACE: return ImGuiKey_Backspace;
210 case SDLK_SPACE: return ImGuiKey_Space;
211 case SDLK_RETURN: return ImGuiKey_Enter;
212 case SDLK_ESCAPE: return ImGuiKey_Escape;
213 case SDLK_QUOTE: return ImGuiKey_Apostrophe;
214 case SDLK_COMMA: return ImGuiKey_Comma;
215 case SDLK_MINUS: return ImGuiKey_Minus;
216 case SDLK_PERIOD: return ImGuiKey_Period;
217 case SDLK_SLASH: return ImGuiKey_Slash;
218 case SDLK_SEMICOLON: return ImGuiKey_Semicolon;
219 case SDLK_EQUALS: return ImGuiKey_Equal;
220 case SDLK_LEFTBRACKET: return ImGuiKey_LeftBracket;
221 case SDLK_BACKSLASH: return ImGuiKey_Backslash;
222 case SDLK_RIGHTBRACKET: return ImGuiKey_RightBracket;
223 case SDLK_BACKQUOTE: return ImGuiKey_GraveAccent;
224 case SDLK_CAPSLOCK: return ImGuiKey_CapsLock;
225 case SDLK_SCROLLLOCK: return ImGuiKey_ScrollLock;
226 case SDLK_NUMLOCKCLEAR: return ImGuiKey_NumLock;
227 case SDLK_PRINTSCREEN: return ImGuiKey_PrintScreen;
228 case SDLK_PAUSE: return ImGuiKey_Pause;
229 case SDLK_KP_0: return ImGuiKey_Keypad0;
230 case SDLK_KP_1: return ImGuiKey_Keypad1;
231 case SDLK_KP_2: return ImGuiKey_Keypad2;
232 case SDLK_KP_3: return ImGuiKey_Keypad3;
233 case SDLK_KP_4: return ImGuiKey_Keypad4;
234 case SDLK_KP_5: return ImGuiKey_Keypad5;
235 case SDLK_KP_6: return ImGuiKey_Keypad6;
236 case SDLK_KP_7: return ImGuiKey_Keypad7;
237 case SDLK_KP_8: return ImGuiKey_Keypad8;
238 case SDLK_KP_9: return ImGuiKey_Keypad9;
239 case SDLK_KP_PERIOD: return ImGuiKey_KeypadDecimal;
240 case SDLK_KP_DIVIDE: return ImGuiKey_KeypadDivide;
241 case SDLK_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
242 case SDLK_KP_MINUS: return ImGuiKey_KeypadSubtract;
243 case SDLK_KP_PLUS: return ImGuiKey_KeypadAdd;
244 case SDLK_KP_ENTER: return ImGuiKey_KeypadEnter;
245 case SDLK_KP_EQUALS: return ImGuiKey_KeypadEqual;
246 case SDLK_LCTRL: return ImGuiKey_LeftCtrl;
247 case SDLK_LSHIFT: return ImGuiKey_LeftShift;
248 case SDLK_LALT: return ImGuiKey_LeftAlt;
249 case SDLK_LGUI: return ImGuiKey_LeftSuper;
250 case SDLK_RCTRL: return ImGuiKey_RightCtrl;
251 case SDLK_RSHIFT: return ImGuiKey_RightShift;
252 case SDLK_RALT: return ImGuiKey_RightAlt;
253 case SDLK_RGUI: return ImGuiKey_RightSuper;
254 case SDLK_APPLICATION: return ImGuiKey_Menu;
255 case SDLK_0: return ImGuiKey_0;
256 case SDLK_1: return ImGuiKey_1;
257 case SDLK_2: return ImGuiKey_2;
258 case SDLK_3: return ImGuiKey_3;
259 case SDLK_4: return ImGuiKey_4;
260 case SDLK_5: return ImGuiKey_5;
261 case SDLK_6: return ImGuiKey_6;
262 case SDLK_7: return ImGuiKey_7;
263 case SDLK_8: return ImGuiKey_8;
264 case SDLK_9: return ImGuiKey_9;
265 case SDLK_a: return ImGuiKey_A;
266 case SDLK_b: return ImGuiKey_B;
267 case SDLK_c: return ImGuiKey_C;
268 case SDLK_d: return ImGuiKey_D;
269 case SDLK_e: return ImGuiKey_E;
270 case SDLK_f: return ImGuiKey_F;
271 case SDLK_g: return ImGuiKey_G;
272 case SDLK_h: return ImGuiKey_H;
273 case SDLK_i: return ImGuiKey_I;
274 case SDLK_j: return ImGuiKey_J;
275 case SDLK_k: return ImGuiKey_K;
276 case SDLK_l: return ImGuiKey_L;
277 case SDLK_m: return ImGuiKey_M;
278 case SDLK_n: return ImGuiKey_N;
279 case SDLK_o: return ImGuiKey_O;
280 case SDLK_p: return ImGuiKey_P;
281 case SDLK_q: return ImGuiKey_Q;
282 case SDLK_r: return ImGuiKey_R;
283 case SDLK_s: return ImGuiKey_S;
284 case SDLK_t: return ImGuiKey_T;
285 case SDLK_u: return ImGuiKey_U;
286 case SDLK_v: return ImGuiKey_V;
287 case SDLK_w: return ImGuiKey_W;
288 case SDLK_x: return ImGuiKey_X;
289 case SDLK_y: return ImGuiKey_Y;
290 case SDLK_z: return ImGuiKey_Z;
291 case SDLK_F1: return ImGuiKey_F1;
292 case SDLK_F2: return ImGuiKey_F2;
293 case SDLK_F3: return ImGuiKey_F3;
294 case SDLK_F4: return ImGuiKey_F4;
295 case SDLK_F5: return ImGuiKey_F5;
296 case SDLK_F6: return ImGuiKey_F6;
297 case SDLK_F7: return ImGuiKey_F7;
298 case SDLK_F8: return ImGuiKey_F8;
299 case SDLK_F9: return ImGuiKey_F9;
300 case SDLK_F10: return ImGuiKey_F10;
301 case SDLK_F11: return ImGuiKey_F11;
302 case SDLK_F12: return ImGuiKey_F12;
303 case SDLK_F13: return ImGuiKey_F13;
304 case SDLK_F14: return ImGuiKey_F14;
305 case SDLK_F15: return ImGuiKey_F15;
306 case SDLK_F16: return ImGuiKey_F16;
307 case SDLK_F17: return ImGuiKey_F17;
308 case SDLK_F18: return ImGuiKey_F18;
309 case SDLK_F19: return ImGuiKey_F19;
310 case SDLK_F20: return ImGuiKey_F20;
311 case SDLK_F21: return ImGuiKey_F21;
312 case SDLK_F22: return ImGuiKey_F22;
313 case SDLK_F23: return ImGuiKey_F23;
314 case SDLK_F24: return ImGuiKey_F24;
315 case SDLK_AC_BACK: return ImGuiKey_AppBack;
316 case SDLK_AC_FORWARD: return ImGuiKey_AppForward;
317 default: break;
318 }
319 return ImGuiKey_None;
320}
321
322static void ImGui_ImplSDL2_UpdateKeyModifiers(SDL_Keymod sdl_key_mods)
323{
324 ImGuiIO& io = ImGui::GetIO();
325 io.AddKeyEvent(ImGuiMod_Ctrl, (sdl_key_mods & KMOD_CTRL) != 0);
326 io.AddKeyEvent(ImGuiMod_Shift, (sdl_key_mods & KMOD_SHIFT) != 0);
327 io.AddKeyEvent(ImGuiMod_Alt, (sdl_key_mods & KMOD_ALT) != 0);
328 io.AddKeyEvent(ImGuiMod_Super, (sdl_key_mods & KMOD_GUI) != 0);
329}
330
331// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
332// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
333// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
334// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
335// If you have multiple SDL events and some of them are not meant to be used by dear imgui, you may need to filter events based on their windowID field.
336bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event)
337{
338 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
339 IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplSDL2_Init()?");
340 ImGuiIO& io = ImGui::GetIO();
341
342 switch (event->type)
343 {
344 case SDL_MOUSEMOTION:
345 {
346 ImVec2 mouse_pos((float)event->motion.x, (float)event->motion.y);
347 if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
348 {
349 int window_x, window_y;
350 SDL_GetWindowPosition(SDL_GetWindowFromID(event->motion.windowID), &window_x, &window_y);
351 mouse_pos.x += window_x;
352 mouse_pos.y += window_y;
353 }
354 io.AddMouseSourceEvent(event->motion.which == SDL_TOUCH_MOUSEID ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse);
355 io.AddMousePosEvent(mouse_pos.x, mouse_pos.y);
356 return true;
357 }
358 case SDL_MOUSEWHEEL:
359 {
360 //IMGUI_DEBUG_LOG("wheel %.2f %.2f, precise %.2f %.2f\n", (float)event->wheel.x, (float)event->wheel.y, event->wheel.preciseX, event->wheel.preciseY);
361#if SDL_VERSION_ATLEAST(2,0,18) // If this fails to compile on Emscripten: update to latest Emscripten!
362 float wheel_x = -event->wheel.preciseX;
363 float wheel_y = event->wheel.preciseY;
364#else
365 float wheel_x = -(float)event->wheel.x;
366 float wheel_y = (float)event->wheel.y;
367#endif
368#ifdef __EMSCRIPTEN__
369 wheel_x /= 100.0f;
370#endif
371 io.AddMouseSourceEvent(event->wheel.which == SDL_TOUCH_MOUSEID ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse);
372 io.AddMouseWheelEvent(wheel_x, wheel_y);
373 return true;
374 }
375 case SDL_MOUSEBUTTONDOWN:
376 case SDL_MOUSEBUTTONUP:
377 {
378 int mouse_button = -1;
379 if (event->button.button == SDL_BUTTON_LEFT) { mouse_button = 0; }
380 if (event->button.button == SDL_BUTTON_RIGHT) { mouse_button = 1; }
381 if (event->button.button == SDL_BUTTON_MIDDLE) { mouse_button = 2; }
382 if (event->button.button == SDL_BUTTON_X1) { mouse_button = 3; }
383 if (event->button.button == SDL_BUTTON_X2) { mouse_button = 4; }
384 if (mouse_button == -1)
385 break;
386 io.AddMouseSourceEvent(event->button.which == SDL_TOUCH_MOUSEID ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse);
387 io.AddMouseButtonEvent(mouse_button, (event->type == SDL_MOUSEBUTTONDOWN));
388 bd->MouseButtonsDown = (event->type == SDL_MOUSEBUTTONDOWN) ? (bd->MouseButtonsDown | (1 << mouse_button)) : (bd->MouseButtonsDown & ~(1 << mouse_button));
389 return true;
390 }
391 case SDL_TEXTINPUT:
392 {
393 io.AddInputCharactersUTF8(event->text.text);
394 return true;
395 }
396 case SDL_KEYDOWN:
397 case SDL_KEYUP:
398 {
399 ImGui_ImplSDL2_UpdateKeyModifiers((SDL_Keymod)event->key.keysym.mod);
400 ImGuiKey key = ImGui_ImplSDL2_KeyEventToImGuiKey(event->key.keysym.sym, event->key.keysym.scancode);
401 io.AddKeyEvent(key, (event->type == SDL_KEYDOWN));
402 io.SetKeyEventNativeData(key, event->key.keysym.sym, event->key.keysym.scancode, event->key.keysym.scancode); // To support legacy indexing (<1.87 user code). Legacy backend uses SDLK_*** as indices to IsKeyXXX() functions.
403 return true;
404 }
405#if SDL_HAS_DISPLAY_EVENT
406 case SDL_DISPLAYEVENT:
407 {
408 // 2.0.26 has SDL_DISPLAYEVENT_CONNECTED/SDL_DISPLAYEVENT_DISCONNECTED/SDL_DISPLAYEVENT_ORIENTATION,
409 // so change of DPI/Scaling are not reflected in this event. (SDL3 has it)
410 bd->WantUpdateMonitors = true;
411 return true;
412 }
413#endif
414 case SDL_WINDOWEVENT:
415 {
416 // - When capturing mouse, SDL will send a bunch of conflicting LEAVE/ENTER event on every mouse move, but the final ENTER tends to be right.
417 // - However we won't get a correct LEAVE event for a captured window.
418 // - In some cases, when detaching a window from main viewport SDL may send SDL_WINDOWEVENT_ENTER one frame too late,
419 // causing SDL_WINDOWEVENT_LEAVE on previous frame to interrupt drag operation by clear mouse position. This is why
420 // we delay process the SDL_WINDOWEVENT_LEAVE events by one frame. See issue #5012 for details.
421 Uint8 window_event = event->window.event;
422 if (window_event == SDL_WINDOWEVENT_ENTER)
423 {
424 bd->MouseWindowID = event->window.windowID;
425 bd->MouseLastLeaveFrame = 0;
426 }
427 if (window_event == SDL_WINDOWEVENT_LEAVE)
428 bd->MouseLastLeaveFrame = ImGui::GetFrameCount() + 1;
429 if (window_event == SDL_WINDOWEVENT_FOCUS_GAINED)
430 io.AddFocusEvent(true);
431 else if (window_event == SDL_WINDOWEVENT_FOCUS_LOST)
432 io.AddFocusEvent(false);
433 if (window_event == SDL_WINDOWEVENT_CLOSE || window_event == SDL_WINDOWEVENT_MOVED || window_event == SDL_WINDOWEVENT_RESIZED)
434 if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle((void*)SDL_GetWindowFromID(event->window.windowID)))
435 {
436 if (window_event == SDL_WINDOWEVENT_CLOSE)
437 viewport->PlatformRequestClose = true;
438 if (window_event == SDL_WINDOWEVENT_MOVED)
439 viewport->PlatformRequestMove = true;
440 if (window_event == SDL_WINDOWEVENT_RESIZED)
441 viewport->PlatformRequestResize = true;
442 return true;
443 }
444 return true;
445 }
446 case SDL_CONTROLLERDEVICEADDED:
447 case SDL_CONTROLLERDEVICEREMOVED:
448 {
449 bd->WantUpdateGamepadsList = true;
450 return true;
451 }
452 }
453 return false;
454}
455
456#ifdef __EMSCRIPTEN__
457EM_JS(void, ImGui_ImplSDL2_EmscriptenOpenURL, (char const* url), { url = url ? UTF8ToString(url) : null; if (url) window.open(url, '_blank'); });
458#endif
459
460static bool ImGui_ImplSDL2_Init(SDL_Window* window, SDL_Renderer* renderer, void* sdl_gl_context)
461{
462 ImGuiIO& io = ImGui::GetIO();
463 IMGUI_CHECKVERSION();
464 IM_ASSERT(io.BackendPlatformUserData == nullptr && "Already initialized a platform backend!");
465
466 // Check and store if we are on a SDL backend that supports global mouse position
467 // ("wayland" and "rpi" don't support it, but we chose to use a white-list instead of a black-list)
468 bool mouse_can_use_global_state = false;
469#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
470 const char* sdl_backend = SDL_GetCurrentVideoDriver();
471 const char* global_mouse_whitelist[] = { "windows", "cocoa", "x11", "DIVE", "VMAN" };
472 for (int n = 0; n < IM_ARRAYSIZE(global_mouse_whitelist); n++)
473 if (strncmp(sdl_backend, global_mouse_whitelist[n], strlen(global_mouse_whitelist[n])) == 0)
474 mouse_can_use_global_state = true;
475#endif
476
477 // Setup backend capabilities flags
479 io.BackendPlatformUserData = (void*)bd;
480 io.BackendPlatformName = "imgui_impl_sdl2";
481 io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
482 io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
483 if (mouse_can_use_global_state)
484 io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
485
486 bd->Window = window;
487 bd->Renderer = renderer;
488
489 // SDL on Linux/OSX doesn't report events for unfocused windows (see https://github.com/ocornut/imgui/issues/4960)
490 // We will use 'MouseCanReportHoveredViewport' to set 'ImGuiBackendFlags_HasMouseHoveredViewport' dynamically each frame.
491 bd->MouseCanUseGlobalState = mouse_can_use_global_state;
492#ifndef __APPLE__
494#else
496#endif
497 bd->WantUpdateMonitors = true;
498
499 io.SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText;
500 io.GetClipboardTextFn = ImGui_ImplSDL2_GetClipboardText;
501 io.ClipboardUserData = nullptr;
502 io.PlatformSetImeDataFn = ImGui_ImplSDL2_PlatformSetImeData;
503#ifdef __EMSCRIPTEN__
504 io.PlatformOpenInShellFn = [](ImGuiContext*, const char* url) { ImGui_ImplSDL2_EmscriptenOpenURL(url); return true; };
505#endif
506
507 // Gamepad handling
508 bd->GamepadMode = ImGui_ImplSDL2_GamepadMode_AutoFirst;
509 bd->WantUpdateGamepadsList = true;
510
511 // Load mouse cursors
512 bd->MouseCursors[ImGuiMouseCursor_Arrow] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
513 bd->MouseCursors[ImGuiMouseCursor_TextInput] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
514 bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL);
515 bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENS);
516 bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE);
517 bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENESW);
518 bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENWSE);
519 bd->MouseCursors[ImGuiMouseCursor_Hand] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
520 bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_NO);
521
522 // Set platform dependent data in viewport
523 // Our mouse update function expect PlatformHandle to be filled for the main viewport
524 ImGuiViewport* main_viewport = ImGui::GetMainViewport();
525 main_viewport->PlatformHandle = (void*)window;
526 main_viewport->PlatformHandleRaw = nullptr;
527 SDL_SysWMinfo info;
528 SDL_VERSION(&info.version);
529 if (SDL_GetWindowWMInfo(window, &info))
530 {
531#if defined(SDL_VIDEO_DRIVER_WINDOWS)
532 main_viewport->PlatformHandleRaw = (void*)info.info.win.window;
533#elif defined(__APPLE__) && defined(SDL_VIDEO_DRIVER_COCOA)
534 main_viewport->PlatformHandleRaw = (void*)info.info.cocoa.window;
535#endif
536 }
537
538 // From 2.0.5: Set SDL hint to receive mouse click events on window focus, otherwise SDL doesn't emit the event.
539 // Without this, when clicking to gain focus, our widgets wouldn't activate even though they showed as hovered.
540 // (This is unfortunately a global SDL setting, so enabling it might have a side-effect on your application.
541 // It is unlikely to make a difference, but if your app absolutely needs to ignore the initial on-focus click:
542 // you can ignore SDL_MOUSEBUTTONDOWN events coming right after a SDL_WINDOWEVENT_FOCUS_GAINED)
543#ifdef SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH
544 SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1");
545#endif
546
547 // From 2.0.18: Enable native IME.
548 // IMPORTANT: This is used at the time of SDL_CreateWindow() so this will only affects secondary windows, if any.
549 // For the main window to be affected, your application needs to call this manually before calling SDL_CreateWindow().
550#ifdef SDL_HINT_IME_SHOW_UI
551 SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
552#endif
553
554 // From 2.0.22: Disable auto-capture, this is preventing drag and drop across multiple windows (see #5710)
555#ifdef SDL_HINT_MOUSE_AUTO_CAPTURE
556 SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0");
557#endif
558
559 // We need SDL_CaptureMouse(), SDL_GetGlobalMouseState() from SDL 2.0.4+ to support multiple viewports.
560 // We left the call to ImGui_ImplSDL2_InitPlatformInterface() outside of #ifdef to avoid unused-function warnings.
561 if ((io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) && (io.BackendFlags & ImGuiBackendFlags_PlatformHasViewports))
562 ImGui_ImplSDL2_InitPlatformInterface(window, sdl_gl_context);
563
564 return true;
565}
566
567bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context)
568{
569 return ImGui_ImplSDL2_Init(window, nullptr, sdl_gl_context);
570}
571
572bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window)
573{
574#if !SDL_HAS_VULKAN
575 IM_ASSERT(0 && "Unsupported");
576#endif
577 if (!ImGui_ImplSDL2_Init(window, nullptr, nullptr))
578 return false;
579 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
580 bd->UseVulkan = true;
581 return true;
582}
583
584bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window)
585{
586#if !defined(_WIN32)
587 IM_ASSERT(0 && "Unsupported");
588#endif
589 return ImGui_ImplSDL2_Init(window, nullptr, nullptr);
590}
591
592bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window)
593{
594 return ImGui_ImplSDL2_Init(window, nullptr, nullptr);
595}
596
597bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window, SDL_Renderer* renderer)
598{
599 return ImGui_ImplSDL2_Init(window, renderer, nullptr);
600}
601
602bool ImGui_ImplSDL2_InitForOther(SDL_Window* window)
603{
604 return ImGui_ImplSDL2_Init(window, nullptr, nullptr);
605}
606
607static void ImGui_ImplSDL2_CloseGamepads();
608
610{
611 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
612 IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
613 ImGuiIO& io = ImGui::GetIO();
614
615 ImGui_ImplSDL2_ShutdownPlatformInterface();
616
617 if (bd->ClipboardTextData)
618 SDL_free(bd->ClipboardTextData);
619 for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
620 SDL_FreeCursor(bd->MouseCursors[cursor_n]);
621 ImGui_ImplSDL2_CloseGamepads();
622
623 io.BackendPlatformName = nullptr;
624 io.BackendPlatformUserData = nullptr;
625 io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_HasMouseHoveredViewport);
626 IM_DELETE(bd);
627}
628
629// This code is incredibly messy because some of the functions we need for full viewport support are not available in SDL < 2.0.4.
630static void ImGui_ImplSDL2_UpdateMouseData()
631{
632 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
633 ImGuiIO& io = ImGui::GetIO();
634
635 // We forward mouse input when hovered or captured (via SDL_MOUSEMOTION) or when focused (below)
636#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
637 // SDL_CaptureMouse() let the OS know e.g. that our imgui drag outside the SDL window boundaries shouldn't e.g. trigger other operations outside
638 SDL_CaptureMouse((bd->MouseButtonsDown != 0) ? SDL_TRUE : SDL_FALSE);
639 SDL_Window* focused_window = SDL_GetKeyboardFocus();
640 const bool is_app_focused = (focused_window && (bd->Window == focused_window || ImGui::FindViewportByPlatformHandle((void*)focused_window)));
641#else
642 SDL_Window* focused_window = bd->Window;
643 const bool is_app_focused = (SDL_GetWindowFlags(bd->Window) & SDL_WINDOW_INPUT_FOCUS) != 0; // SDL 2.0.3 and non-windowed systems: single-viewport only
644#endif
645
646 if (is_app_focused)
647 {
648 // (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
649 if (io.WantSetMousePos)
650 {
651#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
652 if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
653 SDL_WarpMouseGlobal((int)io.MousePos.x, (int)io.MousePos.y);
654 else
655#endif
656 SDL_WarpMouseInWindow(bd->Window, (int)io.MousePos.x, (int)io.MousePos.y);
657 }
658
659 // (Optional) Fallback to provide mouse position when focused (SDL_MOUSEMOTION already provides this when hovered or captured)
660 if (bd->MouseCanUseGlobalState && bd->MouseButtonsDown == 0)
661 {
662 // 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)
663 // 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)
664 int mouse_x, mouse_y, window_x, window_y;
665 SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
666 if (!(io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable))
667 {
668 SDL_GetWindowPosition(focused_window, &window_x, &window_y);
669 mouse_x -= window_x;
670 mouse_y -= window_y;
671 }
672 io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
673 }
674 }
675
676 // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
677 // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
678 // - [!] SDL backend does NOT correctly ignore viewports with the _NoInputs flag.
679 // 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
680 // 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
681 // by the backend, and use its flawed heuristic to guess the viewport behind.
682 // - [X] SDL backend correctly reports this regardless of another viewport behind focused and dragged from (we need this to find a useful drag and drop target).
683 if (io.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
684 {
685 ImGuiID mouse_viewport_id = 0;
686 if (SDL_Window* sdl_mouse_window = SDL_GetWindowFromID(bd->MouseWindowID))
687 if (ImGuiViewport* mouse_viewport = ImGui::FindViewportByPlatformHandle((void*)sdl_mouse_window))
688 mouse_viewport_id = mouse_viewport->ID;
689 io.AddMouseViewportEvent(mouse_viewport_id);
690 }
691}
692
693static void ImGui_ImplSDL2_UpdateMouseCursor()
694{
695 ImGuiIO& io = ImGui::GetIO();
696 if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
697 return;
698 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
699
700 ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
701 if (io.MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None)
702 {
703 // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
704 SDL_ShowCursor(SDL_FALSE);
705 }
706 else
707 {
708 // Show OS mouse cursor
709 SDL_Cursor* expected_cursor = bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow];
710 if (bd->MouseLastCursor != expected_cursor)
711 {
712 SDL_SetCursor(expected_cursor); // SDL function doesn't have an early out (see #6113)
713 bd->MouseLastCursor = expected_cursor;
714 }
715 SDL_ShowCursor(SDL_TRUE);
716 }
717}
718
719static void ImGui_ImplSDL2_CloseGamepads()
720{
721 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
722 if (bd->GamepadMode != ImGui_ImplSDL2_GamepadMode_Manual)
723 for (SDL_GameController* gamepad : bd->Gamepads)
724 SDL_GameControllerClose(gamepad);
725 bd->Gamepads.resize(0);
726}
727
728void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode, struct _SDL_GameController** manual_gamepads_array, int manual_gamepads_count)
729{
730 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
731 ImGui_ImplSDL2_CloseGamepads();
732 if (mode == ImGui_ImplSDL2_GamepadMode_Manual)
733 {
734 IM_ASSERT(manual_gamepads_array != nullptr && manual_gamepads_count > 0);
735 for (int n = 0; n < manual_gamepads_count; n++)
736 bd->Gamepads.push_back(manual_gamepads_array[n]);
737 }
738 else
739 {
740 IM_ASSERT(manual_gamepads_array == nullptr && manual_gamepads_count <= 0);
741 bd->WantUpdateGamepadsList = true;
742 }
743 bd->GamepadMode = mode;
744}
745
746static void ImGui_ImplSDL2_UpdateGamepadButton(ImGui_ImplSDL2_Data* bd, ImGuiIO& io, ImGuiKey key, SDL_GameControllerButton button_no)
747{
748 bool merged_value = false;
749 for (SDL_GameController* gamepad : bd->Gamepads)
750 merged_value |= SDL_GameControllerGetButton(gamepad, button_no) != 0;
751 io.AddKeyEvent(key, merged_value);
752}
753
754static inline float Saturate(float v) { return v < 0.0f ? 0.0f : v > 1.0f ? 1.0f : v; }
755static void ImGui_ImplSDL2_UpdateGamepadAnalog(ImGui_ImplSDL2_Data* bd, ImGuiIO& io, ImGuiKey key, SDL_GameControllerAxis axis_no, float v0, float v1)
756{
757 float merged_value = 0.0f;
758 for (SDL_GameController* gamepad : bd->Gamepads)
759 {
760 float vn = Saturate((float)(SDL_GameControllerGetAxis(gamepad, axis_no) - v0) / (float)(v1 - v0));
761 if (merged_value < vn)
762 merged_value = vn;
763 }
764 io.AddKeyAnalogEvent(key, merged_value > 0.1f, merged_value);
765}
766
767static void ImGui_ImplSDL2_UpdateGamepads()
768{
769 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
770 ImGuiIO& io = ImGui::GetIO();
771
772 // Update list of controller(s) to use
773 if (bd->WantUpdateGamepadsList && bd->GamepadMode != ImGui_ImplSDL2_GamepadMode_Manual)
774 {
775 ImGui_ImplSDL2_CloseGamepads();
776 int joystick_count = SDL_NumJoysticks();
777 for (int n = 0; n < joystick_count; n++)
778 if (SDL_IsGameController(n))
779 if (SDL_GameController* gamepad = SDL_GameControllerOpen(n))
780 {
781 bd->Gamepads.push_back(gamepad);
782 if (bd->GamepadMode == ImGui_ImplSDL2_GamepadMode_AutoFirst)
783 break;
784 }
785 bd->WantUpdateGamepadsList = false;
786 }
787
788 // FIXME: Technically feeding gamepad shouldn't depend on this now that they are regular inputs.
789 if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
790 return;
791 io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
792 if (bd->Gamepads.Size == 0)
793 return;
794 io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
795
796 // Update gamepad inputs
797 const int thumb_dead_zone = 8000; // SDL_gamecontroller.h suggests using this value.
798 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadStart, SDL_CONTROLLER_BUTTON_START);
799 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadBack, SDL_CONTROLLER_BUTTON_BACK);
800 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadFaceLeft, SDL_CONTROLLER_BUTTON_X); // Xbox X, PS Square
801 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadFaceRight, SDL_CONTROLLER_BUTTON_B); // Xbox B, PS Circle
802 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadFaceUp, SDL_CONTROLLER_BUTTON_Y); // Xbox Y, PS Triangle
803 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadFaceDown, SDL_CONTROLLER_BUTTON_A); // Xbox A, PS Cross
804 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadDpadLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
805 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadDpadRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
806 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadDpadUp, SDL_CONTROLLER_BUTTON_DPAD_UP);
807 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadDpadDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
808 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadL1, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
809 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadR1, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
810 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadL2, SDL_CONTROLLER_AXIS_TRIGGERLEFT, 0.0f, 32767);
811 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadR2, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, 0.0f, 32767);
812 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadL3, SDL_CONTROLLER_BUTTON_LEFTSTICK);
813 ImGui_ImplSDL2_UpdateGamepadButton(bd, io, ImGuiKey_GamepadR3, SDL_CONTROLLER_BUTTON_RIGHTSTICK);
814 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadLStickLeft, SDL_CONTROLLER_AXIS_LEFTX, -thumb_dead_zone, -32768);
815 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadLStickRight, SDL_CONTROLLER_AXIS_LEFTX, +thumb_dead_zone, +32767);
816 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadLStickUp, SDL_CONTROLLER_AXIS_LEFTY, -thumb_dead_zone, -32768);
817 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadLStickDown, SDL_CONTROLLER_AXIS_LEFTY, +thumb_dead_zone, +32767);
818 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadRStickLeft, SDL_CONTROLLER_AXIS_RIGHTX, -thumb_dead_zone, -32768);
819 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadRStickRight, SDL_CONTROLLER_AXIS_RIGHTX, +thumb_dead_zone, +32767);
820 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadRStickUp, SDL_CONTROLLER_AXIS_RIGHTY, -thumb_dead_zone, -32768);
821 ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadRStickDown, SDL_CONTROLLER_AXIS_RIGHTY, +thumb_dead_zone, +32767);
822}
823
824// FIXME: Note that doesn't update with DPI/Scaling change only as SDL2 doesn't have an event for it (SDL3 has).
825static void ImGui_ImplSDL2_UpdateMonitors()
826{
827 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
828 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
829 platform_io.Monitors.resize(0);
830 bd->WantUpdateMonitors = false;
831 int display_count = SDL_GetNumVideoDisplays();
832 for (int n = 0; n < display_count; n++)
833 {
834 // Warning: the validity of monitor DPI information on Windows depends on the application DPI awareness settings, which generally needs to be set in the manifest or at runtime.
835 ImGuiPlatformMonitor monitor;
836 SDL_Rect r;
837 SDL_GetDisplayBounds(n, &r);
838 monitor.MainPos = monitor.WorkPos = ImVec2((float)r.x, (float)r.y);
839 monitor.MainSize = monitor.WorkSize = ImVec2((float)r.w, (float)r.h);
840#if SDL_HAS_USABLE_DISPLAY_BOUNDS
841 SDL_GetDisplayUsableBounds(n, &r);
842 monitor.WorkPos = ImVec2((float)r.x, (float)r.y);
843 monitor.WorkSize = ImVec2((float)r.w, (float)r.h);
844#endif
845#if SDL_HAS_PER_MONITOR_DPI
846 // FIXME-VIEWPORT: On MacOS SDL reports actual monitor DPI scale, ignoring OS configuration. We may want to set
847 // DpiScale to cocoa_window.backingScaleFactor here.
848 float dpi = 0.0f;
849 if (!SDL_GetDisplayDPI(n, &dpi, nullptr, nullptr))
850 monitor.DpiScale = dpi / 96.0f;
851#endif
852 monitor.PlatformHandle = (void*)(intptr_t)n;
853 platform_io.Monitors.push_back(monitor);
854 }
855}
856
858{
859 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
860 IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplSDL2_Init()?");
861 ImGuiIO& io = ImGui::GetIO();
862
863 // Setup display size (every frame to accommodate for window resizing)
864 int w, h;
865 int display_w, display_h;
866 SDL_GetWindowSize(bd->Window, &w, &h);
867 if (SDL_GetWindowFlags(bd->Window) & SDL_WINDOW_MINIMIZED)
868 w = h = 0;
869 if (bd->Renderer != nullptr)
870 SDL_GetRendererOutputSize(bd->Renderer, &display_w, &display_h);
871 else
872 SDL_GL_GetDrawableSize(bd->Window, &display_w, &display_h);
873 io.DisplaySize = ImVec2((float)w, (float)h);
874 if (w > 0 && h > 0)
875 io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
876
877 // Update monitors
878 if (bd->WantUpdateMonitors)
879 ImGui_ImplSDL2_UpdateMonitors();
880
881 // Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
882 // (Accept SDL_GetPerformanceCounter() not returning a monotonically increasing value. Happens in VMs and Emscripten, see #6189, #6114, #3644)
883 static Uint64 frequency = SDL_GetPerformanceFrequency();
884 Uint64 current_time = SDL_GetPerformanceCounter();
885 if (current_time <= bd->Time)
886 current_time = bd->Time + 1;
887 io.DeltaTime = bd->Time > 0 ? (float)((double)(current_time - bd->Time) / frequency) : (float)(1.0f / 60.0f);
888 bd->Time = current_time;
889
890 if (bd->MouseLastLeaveFrame && bd->MouseLastLeaveFrame >= ImGui::GetFrameCount() && bd->MouseButtonsDown == 0)
891 {
892 bd->MouseWindowID = 0;
893 bd->MouseLastLeaveFrame = 0;
894 io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
895 }
896
897 // Our io.AddMouseViewportEvent() calls will only be valid when not capturing.
898 // Technically speaking testing for 'bd->MouseButtonsDown == 0' would be more rigorous, but testing for payload reduces noise and potential side-effects.
899 if (bd->MouseCanReportHoveredViewport && ImGui::GetDragDropPayload() == nullptr)
900 io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport;
901 else
902 io.BackendFlags &= ~ImGuiBackendFlags_HasMouseHoveredViewport;
903
904 ImGui_ImplSDL2_UpdateMouseData();
905 ImGui_ImplSDL2_UpdateMouseCursor();
906
907 // Update game controllers (if enabled and available)
908 ImGui_ImplSDL2_UpdateGamepads();
909}
910
911//--------------------------------------------------------------------------------------------------------
912// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
913// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
914// 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..
915//--------------------------------------------------------------------------------------------------------
916
917// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
919{
920 SDL_Window* Window;
921 Uint32 WindowID;
923 SDL_GLContext GLContext;
924
925 ImGui_ImplSDL2_ViewportData() { Window = nullptr; WindowID = 0; WindowOwned = false; GLContext = nullptr; }
926 ~ImGui_ImplSDL2_ViewportData() { IM_ASSERT(Window == nullptr && GLContext == nullptr); }
927};
928
929static void ImGui_ImplSDL2_CreateWindow(ImGuiViewport* viewport)
930{
931 ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
933 viewport->PlatformUserData = vd;
934
935 ImGuiViewport* main_viewport = ImGui::GetMainViewport();
936 ImGui_ImplSDL2_ViewportData* main_viewport_data = (ImGui_ImplSDL2_ViewportData*)main_viewport->PlatformUserData;
937
938 // Share GL resources with main context
939 bool use_opengl = (main_viewport_data->GLContext != nullptr);
940 SDL_GLContext backup_context = nullptr;
941 if (use_opengl)
942 {
943 backup_context = SDL_GL_GetCurrentContext();
944 SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
945 SDL_GL_MakeCurrent(main_viewport_data->Window, main_viewport_data->GLContext);
946 }
947
948 Uint32 sdl_flags = 0;
949 sdl_flags |= use_opengl ? SDL_WINDOW_OPENGL : (bd->UseVulkan ? SDL_WINDOW_VULKAN : 0);
950 sdl_flags |= SDL_GetWindowFlags(bd->Window) & SDL_WINDOW_ALLOW_HIGHDPI;
951 sdl_flags |= SDL_WINDOW_HIDDEN;
952 sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? SDL_WINDOW_BORDERLESS : 0;
953 sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? 0 : SDL_WINDOW_RESIZABLE;
954#if !defined(_WIN32)
955 // See SDL hack in ImGui_ImplSDL2_ShowWindow().
956 sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon) ? SDL_WINDOW_SKIP_TASKBAR : 0;
957#endif
958#if SDL_HAS_ALWAYS_ON_TOP
959 sdl_flags |= (viewport->Flags & ImGuiViewportFlags_TopMost) ? SDL_WINDOW_ALWAYS_ON_TOP : 0;
960#endif
961 vd->Window = SDL_CreateWindow("No Title Yet", (int)viewport->Pos.x, (int)viewport->Pos.y, (int)viewport->Size.x, (int)viewport->Size.y, sdl_flags);
962 vd->WindowOwned = true;
963 if (use_opengl)
964 {
965 vd->GLContext = SDL_GL_CreateContext(vd->Window);
966 SDL_GL_SetSwapInterval(0);
967 }
968 if (use_opengl && backup_context)
969 SDL_GL_MakeCurrent(vd->Window, backup_context);
970
971 viewport->PlatformHandle = (void*)vd->Window;
972 viewport->PlatformHandleRaw = nullptr;
973 SDL_SysWMinfo info;
974 SDL_VERSION(&info.version);
975 if (SDL_GetWindowWMInfo(vd->Window, &info))
976 {
977#if defined(SDL_VIDEO_DRIVER_WINDOWS)
978 viewport->PlatformHandleRaw = info.info.win.window;
979#elif defined(__APPLE__) && defined(SDL_VIDEO_DRIVER_COCOA)
980 viewport->PlatformHandleRaw = (void*)info.info.cocoa.window;
981#endif
982 }
983}
984
985static void ImGui_ImplSDL2_DestroyWindow(ImGuiViewport* viewport)
986{
987 if (ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData)
988 {
989 if (vd->GLContext && vd->WindowOwned)
990 SDL_GL_DeleteContext(vd->GLContext);
991 if (vd->Window && vd->WindowOwned)
992 SDL_DestroyWindow(vd->Window);
993 vd->GLContext = nullptr;
994 vd->Window = nullptr;
995 IM_DELETE(vd);
996 }
997 viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
998}
999
1000static void ImGui_ImplSDL2_ShowWindow(ImGuiViewport* viewport)
1001{
1002 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1003#if defined(_WIN32)
1004 HWND hwnd = (HWND)viewport->PlatformHandleRaw;
1005
1006 // SDL hack: Hide icon from task bar
1007 // Note: SDL 2.0.6+ has a SDL_WINDOW_SKIP_TASKBAR flag which is supported under Windows but the way it create the window breaks our seamless transition.
1008 if (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon)
1009 {
1010 LONG ex_style = ::GetWindowLong(hwnd, GWL_EXSTYLE);
1011 ex_style &= ~WS_EX_APPWINDOW;
1012 ex_style |= WS_EX_TOOLWINDOW;
1013 ::SetWindowLong(hwnd, GWL_EXSTYLE, ex_style);
1014 }
1015
1016 // SDL hack: SDL always activate/focus windows :/
1017 if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
1018 {
1019 ::ShowWindow(hwnd, SW_SHOWNA);
1020 return;
1021 }
1022#endif
1023
1024 SDL_ShowWindow(vd->Window);
1025}
1026
1027static ImVec2 ImGui_ImplSDL2_GetWindowPos(ImGuiViewport* viewport)
1028{
1029 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1030 int x = 0, y = 0;
1031 SDL_GetWindowPosition(vd->Window, &x, &y);
1032 return ImVec2((float)x, (float)y);
1033}
1034
1035static void ImGui_ImplSDL2_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
1036{
1037 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1038 SDL_SetWindowPosition(vd->Window, (int)pos.x, (int)pos.y);
1039}
1040
1041static ImVec2 ImGui_ImplSDL2_GetWindowSize(ImGuiViewport* viewport)
1042{
1043 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1044 int w = 0, h = 0;
1045 SDL_GetWindowSize(vd->Window, &w, &h);
1046 return ImVec2((float)w, (float)h);
1047}
1048
1049static void ImGui_ImplSDL2_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
1050{
1051 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1052 SDL_SetWindowSize(vd->Window, (int)size.x, (int)size.y);
1053}
1054
1055static void ImGui_ImplSDL2_SetWindowTitle(ImGuiViewport* viewport, const char* title)
1056{
1057 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1058 SDL_SetWindowTitle(vd->Window, title);
1059}
1060
1061#if SDL_HAS_WINDOW_ALPHA
1062static void ImGui_ImplSDL2_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
1063{
1064 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1065 SDL_SetWindowOpacity(vd->Window, alpha);
1066}
1067#endif
1068
1069static void ImGui_ImplSDL2_SetWindowFocus(ImGuiViewport* viewport)
1070{
1071 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1072 SDL_RaiseWindow(vd->Window);
1073}
1074
1075static bool ImGui_ImplSDL2_GetWindowFocus(ImGuiViewport* viewport)
1076{
1077 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1078 return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_INPUT_FOCUS) != 0;
1079}
1080
1081static bool ImGui_ImplSDL2_GetWindowMinimized(ImGuiViewport* viewport)
1082{
1083 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1084 return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_MINIMIZED) != 0;
1085}
1086
1087static void ImGui_ImplSDL2_RenderWindow(ImGuiViewport* viewport, void*)
1088{
1089 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1090 if (vd->GLContext)
1091 SDL_GL_MakeCurrent(vd->Window, vd->GLContext);
1092}
1093
1094static void ImGui_ImplSDL2_SwapBuffers(ImGuiViewport* viewport, void*)
1095{
1096 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1097 if (vd->GLContext)
1098 {
1099 SDL_GL_MakeCurrent(vd->Window, vd->GLContext);
1100 SDL_GL_SwapWindow(vd->Window);
1101 }
1102}
1103
1104// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
1105// SDL is graceful enough to _not_ need <vulkan/vulkan.h> so we can safely include this.
1106#if SDL_HAS_VULKAN
1107#include <SDL_vulkan.h>
1108static int ImGui_ImplSDL2_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface)
1109{
1110 ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
1111 (void)vk_allocator;
1112 SDL_bool ret = SDL_Vulkan_CreateSurface(vd->Window, (VkInstance)vk_instance, (VkSurfaceKHR*)out_vk_surface);
1113 return ret ? 0 : 1; // ret ? VK_SUCCESS : VK_NOT_READY
1114}
1115#endif // SDL_HAS_VULKAN
1116
1117static void ImGui_ImplSDL2_InitPlatformInterface(SDL_Window* window, void* sdl_gl_context)
1118{
1119 // Register platform interface (will be coupled with a renderer interface)
1120 ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
1121 platform_io.Platform_CreateWindow = ImGui_ImplSDL2_CreateWindow;
1122 platform_io.Platform_DestroyWindow = ImGui_ImplSDL2_DestroyWindow;
1123 platform_io.Platform_ShowWindow = ImGui_ImplSDL2_ShowWindow;
1124 platform_io.Platform_SetWindowPos = ImGui_ImplSDL2_SetWindowPos;
1125 platform_io.Platform_GetWindowPos = ImGui_ImplSDL2_GetWindowPos;
1126 platform_io.Platform_SetWindowSize = ImGui_ImplSDL2_SetWindowSize;
1127 platform_io.Platform_GetWindowSize = ImGui_ImplSDL2_GetWindowSize;
1128 platform_io.Platform_SetWindowFocus = ImGui_ImplSDL2_SetWindowFocus;
1129 platform_io.Platform_GetWindowFocus = ImGui_ImplSDL2_GetWindowFocus;
1130 platform_io.Platform_GetWindowMinimized = ImGui_ImplSDL2_GetWindowMinimized;
1131 platform_io.Platform_SetWindowTitle = ImGui_ImplSDL2_SetWindowTitle;
1132 platform_io.Platform_RenderWindow = ImGui_ImplSDL2_RenderWindow;
1133 platform_io.Platform_SwapBuffers = ImGui_ImplSDL2_SwapBuffers;
1134#if SDL_HAS_WINDOW_ALPHA
1135 platform_io.Platform_SetWindowAlpha = ImGui_ImplSDL2_SetWindowAlpha;
1136#endif
1137#if SDL_HAS_VULKAN
1138 platform_io.Platform_CreateVkSurface = ImGui_ImplSDL2_CreateVkSurface;
1139#endif
1140
1141 // Register main window handle (which is owned by the main application, not by us)
1142 // 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.
1143 ImGuiViewport* main_viewport = ImGui::GetMainViewport();
1145 vd->Window = window;
1146 vd->WindowID = SDL_GetWindowID(window);
1147 vd->WindowOwned = false;
1148 vd->GLContext = sdl_gl_context;
1149 main_viewport->PlatformUserData = vd;
1150 main_viewport->PlatformHandle = vd->Window;
1151}
1152
1153static void ImGui_ImplSDL2_ShutdownPlatformInterface()
1154{
1155 ImGui::DestroyPlatformWindows();
1156}
1157
1158//-----------------------------------------------------------------------------
1159
1160#if defined(__clang__)
1161#pragma clang diagnostic pop
1162#endif
1163
1164#endif // #ifndef IMGUI_DISABLE
void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode, struct _SDL_GameController **manual_gamepads_array, int manual_gamepads_count)
bool ImGui_ImplSDL2_InitForVulkan(SDL_Window *window)
bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window *window, SDL_Renderer *renderer)
bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window *window, void *sdl_gl_context)
bool ImGui_ImplSDL2_InitForOther(SDL_Window *window)
bool ImGui_ImplSDL2_InitForMetal(SDL_Window *window)
void ImGui_ImplSDL2_NewFrame()
bool ImGui_ImplSDL2_InitForD3D(SDL_Window *window)
bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event *event)
void ImGui_ImplSDL2_Shutdown()
size_t size(std::string_view utf8)
ImGui_ImplSDL2_GamepadMode GamepadMode
SDL_Renderer * Renderer
SDL_Cursor * MouseLastCursor
SDL_Cursor * MouseCursors[ImGuiMouseCursor_COUNT]
ImVector< SDL_GameController * > Gamepads