2020-10-12 15:34:22 +00:00
// dear imgui: Platform Backend for GLFW
2021-01-28 11:11:26 +00:00
// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
2018-02-21 22:05:17 +00:00
// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
2019-08-29 13:53:33 +00:00
// (Requires: GLFW 3.1+. Prefer GLFW 3.3+ for full feature support.)
2018-02-16 20:38:38 +00:00
// Implemented features:
2018-06-11 10:33:51 +00:00
// [X] Platform: Clipboard support.
2021-12-12 11:00:31 +00:00
// [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 will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
2018-09-20 08:37:55 +00:00
// [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
2019-12-05 14:43:05 +00:00
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
2018-06-12 14:24:24 +00:00
// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2018-02-16 20:38:38 +00:00
2020-07-17 13:57:50 +00:00
// Issues:
// [ ] Platform: Multi-viewport support: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
2021-06-28 14:52:10 +00:00
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
2021-05-27 11:59:35 +00:00
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
2020-10-14 10:22:53 +00:00
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
2018-02-16 20:38:38 +00:00
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
2022-01-13 17:36:23 +00:00
// 2022-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2022-01-21 16:32:35 +00:00
// 2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago)with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
2022-01-20 16:12:22 +00:00
// 2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
2022-01-17 16:22:37 +00:00
// 2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
2022-01-21 16:32:35 +00:00
// 2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
2022-01-12 16:08:37 +00:00
// 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().
2022-01-10 15:59:31 +00:00
// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
2022-01-05 15:54:03 +00:00
// 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.
2021-08-02 18:17:26 +00:00
// 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().
// 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().
2021-06-28 14:52:10 +00:00
// 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).
2020-01-17 10:36:56 +00:00
// 2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
2019-12-05 14:43:05 +00:00
// 2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
2019-10-18 14:25:18 +00:00
// 2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
2019-07-22 01:39:50 +00:00
// 2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
2019-05-11 08:33:56 +00:00
// 2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
2019-03-12 17:27:14 +00:00
// 2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
2018-11-30 17:18:15 +00:00
// 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
2018-11-08 15:24:41 +00:00
// 2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
2018-08-01 09:34:17 +00:00
// 2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
2018-06-29 14:30:41 +00:00
// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
2018-06-08 17:37:33 +00:00
// 2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
2018-04-06 21:34:43 +00:00
// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
2018-04-09 17:35:14 +00:00
// 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
2018-02-16 20:38:38 +00:00
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
2018-02-28 17:51:40 +00:00
// 2018-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
2018-03-20 21:14:34 +00:00
// 2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
2018-02-16 20:38:38 +00:00
// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
// 2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
// 2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
// 2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
# include "imgui.h"
# include "imgui_impl_glfw.h"
2021-12-29 11:41:34 +00:00
// Clang warnings with -Weverything
# if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast
# pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
# if __has_warning("-Wzero-as-null-pointer-constant")
# pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
# endif
# endif
2018-02-27 09:29:37 +00:00
// GLFW
2018-02-16 20:38:38 +00:00
# include <GLFW/glfw3.h>
# ifdef _WIN32
# undef APIENTRY
# define GLFW_EXPOSE_NATIVE_WIN32
2018-03-18 17:44:57 +00:00
# include <GLFW/glfw3native.h> // for glfwGetWin32Window
2018-02-16 20:38:38 +00:00
# endif
2019-05-11 08:54:56 +00:00
# define GLFW_HAS_WINDOW_TOPMOST (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ GLFW_FLOATING
# define GLFW_HAS_WINDOW_HOVERED (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ GLFW_HOVERED
# define GLFW_HAS_WINDOW_ALPHA (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwSetWindowOpacity
# define GLFW_HAS_PER_MONITOR_DPI (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwGetMonitorContentScale
# define GLFW_HAS_VULKAN (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ glfwCreateWindowSurface
# define GLFW_HAS_FOCUS_WINDOW (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ glfwFocusWindow
# define GLFW_HAS_FOCUS_ON_SHOW (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ GLFW_FOCUS_ON_SHOW
# define GLFW_HAS_MONITOR_WORK_AREA (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwGetMonitorWorkarea
2020-03-26 07:42:04 +00:00
# define GLFW_HAS_OSX_WINDOW_POS_FIX (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 + GLFW_VERSION_REVISION * 10 >= 3310) // 3.3.1+ Fixed: Resizing window repositions it on MacOS #1553
2019-12-13 16:06:27 +00:00
# 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?
2019-12-05 14:43:05 +00:00
# define GLFW_HAS_NEW_CURSORS (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
2019-12-06 14:08:04 +00:00
# else
2022-01-21 11:39:15 +00:00
# define GLFW_HAS_NEW_CURSORS (0)
2019-12-06 14:08:04 +00:00
# endif
2020-07-17 13:57:50 +00:00
# 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)
# define GLFW_HAS_MOUSE_PASSTHROUGH (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3400) // 3.4+ GLFW_MOUSE_PASSTHROUGH
# else
# define GLFW_HAS_MOUSE_PASSTHROUGH (0)
# endif
2022-01-21 11:39:15 +00:00
# define GLFW_HAS_GAMEPAD_API (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwGetGamepadState() new api
2022-01-10 14:24:21 +00:00
# define GLFW_HAS_GET_KEY_NAME (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ glfwGetKeyName()
2018-04-11 19:27:19 +00:00
2021-06-28 14:52:10 +00:00
// GLFW data
2018-03-02 18:23:01 +00:00
enum GlfwClientApi
{
GlfwClientApi_Unknown ,
GlfwClientApi_OpenGL ,
2021-02-10 16:27:33 +00:00
GlfwClientApi_Vulkan
2018-03-02 18:23:01 +00:00
} ;
2018-06-08 17:37:33 +00:00
2021-06-28 14:52:10 +00:00
struct ImGui_ImplGlfw_Data
{
GLFWwindow * Window ;
GlfwClientApi ClientApi ;
double Time ;
2021-07-29 16:59:45 +00:00
GLFWwindow * MouseWindow ;
2021-06-28 14:52:10 +00:00
GLFWcursor * MouseCursors [ ImGuiMouseCursor_COUNT ] ;
2022-01-10 14:24:21 +00:00
GLFWwindow * KeyOwnerWindows [ GLFW_KEY_LAST ] ;
2021-06-28 14:52:10 +00:00
bool InstalledCallbacks ;
2021-06-29 12:53:25 +00:00
bool WantUpdateMonitors ;
2021-06-28 14:52:10 +00:00
// Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
2021-08-02 18:17:26 +00:00
GLFWwindowfocusfun PrevUserCallbackWindowFocus ;
2022-01-12 16:08:37 +00:00
GLFWcursorposfun PrevUserCallbackCursorPos ;
2021-07-29 16:59:45 +00:00
GLFWcursorenterfun PrevUserCallbackCursorEnter ;
2021-06-28 14:52:10 +00:00
GLFWmousebuttonfun PrevUserCallbackMousebutton ;
GLFWscrollfun PrevUserCallbackScroll ;
GLFWkeyfun PrevUserCallbackKey ;
GLFWcharfun PrevUserCallbackChar ;
2021-06-29 12:53:25 +00:00
GLFWmonitorfun PrevUserCallbackMonitor ;
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data ( ) { memset ( this , 0 , sizeof ( * this ) ) ; }
} ;
2021-06-29 14:42:13 +00:00
// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
2021-07-07 12:12:48 +00:00
// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
// (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
// - 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.
2021-06-29 14:42:13 +00:00
// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
2021-06-30 13:22:15 +00:00
static ImGui_ImplGlfw_Data * ImGui_ImplGlfw_GetBackendData ( )
{
return ImGui : : GetCurrentContext ( ) ? ( ImGui_ImplGlfw_Data * ) ImGui : : GetIO ( ) . BackendPlatformUserData : NULL ;
}
2018-02-16 20:38:38 +00:00
2018-02-27 22:27:41 +00:00
// Forward Declarations
2020-02-09 16:31:18 +00:00
static void ImGui_ImplGlfw_UpdateMonitors ( ) ;
2018-02-27 22:27:41 +00:00
static void ImGui_ImplGlfw_InitPlatformInterface ( ) ;
static void ImGui_ImplGlfw_ShutdownPlatformInterface ( ) ;
2021-06-28 14:52:10 +00:00
// Functions
2018-02-27 09:29:37 +00:00
static const char * ImGui_ImplGlfw_GetClipboardText ( void * user_data )
2018-02-16 20:38:38 +00:00
{
return glfwGetClipboardString ( ( GLFWwindow * ) user_data ) ;
}
2018-02-27 09:29:37 +00:00
static void ImGui_ImplGlfw_SetClipboardText ( void * user_data , const char * text )
2018-02-16 20:38:38 +00:00
{
glfwSetClipboardString ( ( GLFWwindow * ) user_data , text ) ;
}
2021-12-12 11:00:31 +00:00
static ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey ( int key )
{
switch ( key )
{
case GLFW_KEY_TAB : return ImGuiKey_Tab ;
case GLFW_KEY_LEFT : return ImGuiKey_LeftArrow ;
case GLFW_KEY_RIGHT : return ImGuiKey_RightArrow ;
case GLFW_KEY_UP : return ImGuiKey_UpArrow ;
case GLFW_KEY_DOWN : return ImGuiKey_DownArrow ;
case GLFW_KEY_PAGE_UP : return ImGuiKey_PageUp ;
case GLFW_KEY_PAGE_DOWN : return ImGuiKey_PageDown ;
case GLFW_KEY_HOME : return ImGuiKey_Home ;
case GLFW_KEY_END : return ImGuiKey_End ;
case GLFW_KEY_INSERT : return ImGuiKey_Insert ;
case GLFW_KEY_DELETE : return ImGuiKey_Delete ;
case GLFW_KEY_BACKSPACE : return ImGuiKey_Backspace ;
case GLFW_KEY_SPACE : return ImGuiKey_Space ;
case GLFW_KEY_ENTER : return ImGuiKey_Enter ;
case GLFW_KEY_ESCAPE : return ImGuiKey_Escape ;
case GLFW_KEY_APOSTROPHE : return ImGuiKey_Apostrophe ;
case GLFW_KEY_COMMA : return ImGuiKey_Comma ;
case GLFW_KEY_MINUS : return ImGuiKey_Minus ;
case GLFW_KEY_PERIOD : return ImGuiKey_Period ;
case GLFW_KEY_SLASH : return ImGuiKey_Slash ;
case GLFW_KEY_SEMICOLON : return ImGuiKey_Semicolon ;
case GLFW_KEY_EQUAL : return ImGuiKey_Equal ;
case GLFW_KEY_LEFT_BRACKET : return ImGuiKey_LeftBracket ;
case GLFW_KEY_BACKSLASH : return ImGuiKey_Backslash ;
case GLFW_KEY_RIGHT_BRACKET : return ImGuiKey_RightBracket ;
case GLFW_KEY_GRAVE_ACCENT : return ImGuiKey_GraveAccent ;
case GLFW_KEY_CAPS_LOCK : return ImGuiKey_CapsLock ;
case GLFW_KEY_SCROLL_LOCK : return ImGuiKey_ScrollLock ;
case GLFW_KEY_NUM_LOCK : return ImGuiKey_NumLock ;
case GLFW_KEY_PRINT_SCREEN : return ImGuiKey_PrintScreen ;
case GLFW_KEY_PAUSE : return ImGuiKey_Pause ;
case GLFW_KEY_KP_0 : return ImGuiKey_Keypad0 ;
case GLFW_KEY_KP_1 : return ImGuiKey_Keypad1 ;
case GLFW_KEY_KP_2 : return ImGuiKey_Keypad2 ;
case GLFW_KEY_KP_3 : return ImGuiKey_Keypad3 ;
case GLFW_KEY_KP_4 : return ImGuiKey_Keypad4 ;
case GLFW_KEY_KP_5 : return ImGuiKey_Keypad5 ;
case GLFW_KEY_KP_6 : return ImGuiKey_Keypad6 ;
case GLFW_KEY_KP_7 : return ImGuiKey_Keypad7 ;
case GLFW_KEY_KP_8 : return ImGuiKey_Keypad8 ;
case GLFW_KEY_KP_9 : return ImGuiKey_Keypad9 ;
case GLFW_KEY_KP_DECIMAL : return ImGuiKey_KeypadDecimal ;
case GLFW_KEY_KP_DIVIDE : return ImGuiKey_KeypadDivide ;
case GLFW_KEY_KP_MULTIPLY : return ImGuiKey_KeypadMultiply ;
case GLFW_KEY_KP_SUBTRACT : return ImGuiKey_KeypadSubtract ;
case GLFW_KEY_KP_ADD : return ImGuiKey_KeypadAdd ;
case GLFW_KEY_KP_ENTER : return ImGuiKey_KeypadEnter ;
case GLFW_KEY_KP_EQUAL : return ImGuiKey_KeypadEqual ;
case GLFW_KEY_LEFT_SHIFT : return ImGuiKey_LeftShift ;
2022-01-17 14:41:04 +00:00
case GLFW_KEY_LEFT_CONTROL : return ImGuiKey_LeftCtrl ;
2021-12-12 11:00:31 +00:00
case GLFW_KEY_LEFT_ALT : return ImGuiKey_LeftAlt ;
case GLFW_KEY_LEFT_SUPER : return ImGuiKey_LeftSuper ;
case GLFW_KEY_RIGHT_SHIFT : return ImGuiKey_RightShift ;
2022-01-17 14:41:04 +00:00
case GLFW_KEY_RIGHT_CONTROL : return ImGuiKey_RightCtrl ;
2021-12-12 11:00:31 +00:00
case GLFW_KEY_RIGHT_ALT : return ImGuiKey_RightAlt ;
case GLFW_KEY_RIGHT_SUPER : return ImGuiKey_RightSuper ;
case GLFW_KEY_MENU : return ImGuiKey_Menu ;
case GLFW_KEY_0 : return ImGuiKey_0 ;
case GLFW_KEY_1 : return ImGuiKey_1 ;
case GLFW_KEY_2 : return ImGuiKey_2 ;
case GLFW_KEY_3 : return ImGuiKey_3 ;
case GLFW_KEY_4 : return ImGuiKey_4 ;
case GLFW_KEY_5 : return ImGuiKey_5 ;
case GLFW_KEY_6 : return ImGuiKey_6 ;
case GLFW_KEY_7 : return ImGuiKey_7 ;
case GLFW_KEY_8 : return ImGuiKey_8 ;
case GLFW_KEY_9 : return ImGuiKey_9 ;
case GLFW_KEY_A : return ImGuiKey_A ;
case GLFW_KEY_B : return ImGuiKey_B ;
case GLFW_KEY_C : return ImGuiKey_C ;
case GLFW_KEY_D : return ImGuiKey_D ;
case GLFW_KEY_E : return ImGuiKey_E ;
case GLFW_KEY_F : return ImGuiKey_F ;
case GLFW_KEY_G : return ImGuiKey_G ;
case GLFW_KEY_H : return ImGuiKey_H ;
case GLFW_KEY_I : return ImGuiKey_I ;
case GLFW_KEY_J : return ImGuiKey_J ;
case GLFW_KEY_K : return ImGuiKey_K ;
case GLFW_KEY_L : return ImGuiKey_L ;
case GLFW_KEY_M : return ImGuiKey_M ;
case GLFW_KEY_N : return ImGuiKey_N ;
case GLFW_KEY_O : return ImGuiKey_O ;
case GLFW_KEY_P : return ImGuiKey_P ;
case GLFW_KEY_Q : return ImGuiKey_Q ;
case GLFW_KEY_R : return ImGuiKey_R ;
case GLFW_KEY_S : return ImGuiKey_S ;
case GLFW_KEY_T : return ImGuiKey_T ;
case GLFW_KEY_U : return ImGuiKey_U ;
case GLFW_KEY_V : return ImGuiKey_V ;
case GLFW_KEY_W : return ImGuiKey_W ;
case GLFW_KEY_X : return ImGuiKey_X ;
case GLFW_KEY_Y : return ImGuiKey_Y ;
case GLFW_KEY_Z : return ImGuiKey_Z ;
case GLFW_KEY_F1 : return ImGuiKey_F1 ;
case GLFW_KEY_F2 : return ImGuiKey_F2 ;
case GLFW_KEY_F3 : return ImGuiKey_F3 ;
case GLFW_KEY_F4 : return ImGuiKey_F4 ;
case GLFW_KEY_F5 : return ImGuiKey_F5 ;
case GLFW_KEY_F6 : return ImGuiKey_F6 ;
case GLFW_KEY_F7 : return ImGuiKey_F7 ;
case GLFW_KEY_F8 : return ImGuiKey_F8 ;
case GLFW_KEY_F9 : return ImGuiKey_F9 ;
case GLFW_KEY_F10 : return ImGuiKey_F10 ;
case GLFW_KEY_F11 : return ImGuiKey_F11 ;
case GLFW_KEY_F12 : return ImGuiKey_F12 ;
default : return ImGuiKey_None ;
}
}
2022-01-17 13:57:55 +00:00
static void ImGui_ImplGlfw_UpdateKeyModifiers ( int mods )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-01-21 16:32:35 +00:00
io . AddKeyEvent ( ImGuiKey_ModCtrl , ( mods & GLFW_MOD_CONTROL ) ! = 0 ) ;
io . AddKeyEvent ( ImGuiKey_ModShift , ( mods & GLFW_MOD_SHIFT ) ! = 0 ) ;
io . AddKeyEvent ( ImGuiKey_ModAlt , ( mods & GLFW_MOD_ALT ) ! = 0 ) ;
io . AddKeyEvent ( ImGuiKey_ModSuper , ( mods & GLFW_MOD_SUPER ) ! = 0 ) ;
2022-01-17 13:57:55 +00:00
}
2018-11-08 15:24:41 +00:00
void ImGui_ImplGlfw_MouseButtonCallback ( GLFWwindow * window , int button , int action , int mods )
2018-02-16 20:38:38 +00:00
{
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 12:53:25 +00:00
if ( bd - > PrevUserCallbackMousebutton ! = NULL & & window = = bd - > Window )
2021-06-28 14:52:10 +00:00
bd - > PrevUserCallbackMousebutton ( window , button , action , mods ) ;
2018-11-08 15:24:41 +00:00
2022-01-17 13:57:55 +00:00
ImGui_ImplGlfw_UpdateKeyModifiers ( mods ) ;
2022-01-17 16:22:37 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
if ( button > = 0 & & button < ImGuiMouseButton_COUNT )
io . AddMouseButtonEvent ( button , action = = GLFW_PRESS ) ;
2018-02-16 20:38:38 +00:00
}
2018-11-08 15:24:41 +00:00
void ImGui_ImplGlfw_ScrollCallback ( GLFWwindow * window , double xoffset , double yoffset )
2018-02-16 20:38:38 +00:00
{
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 12:53:25 +00:00
if ( bd - > PrevUserCallbackScroll ! = NULL & & window = = bd - > Window )
2021-06-28 14:52:10 +00:00
bd - > PrevUserCallbackScroll ( window , xoffset , yoffset ) ;
2018-11-08 15:24:41 +00:00
2018-02-16 20:38:38 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-01-17 16:22:37 +00:00
io . AddMouseWheelEvent ( ( float ) xoffset , ( float ) yoffset ) ;
2018-02-16 20:38:38 +00:00
}
2021-12-12 11:00:31 +00:00
static int ImGui_ImplGlfw_TranslateUntranslatedKey ( int key , int scancode )
2018-06-08 17:37:33 +00:00
{
2022-01-14 04:47:53 +00:00
# if GLFW_HAS_GET_KEY_NAME && !defined(__EMSCRIPTEN__)
2022-01-05 15:54:03 +00:00
// GLFW 3.1+ attempts to "untranslate" keys, which goes the opposite of what every other framework does, making using lettered shortcuts difficult.
// (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)
// See https://github.com/glfw/glfw/issues/1502 for details.
// Adding a workaround to undo this (so our keys are translated->untranslated->translated, likely a lossy process).
// This won't cover edge cases but this is at least going to cover common cases.
2022-02-01 14:27:10 +00:00
if ( key > = GLFW_KEY_KP_0 & & key < = GLFW_KEY_KP_EQUAL )
return key ;
2022-01-05 15:54:03 +00:00
const char * key_name = glfwGetKeyName ( key , scancode ) ;
if ( key_name & & key_name [ 0 ] ! = 0 & & key_name [ 1 ] = = 0 )
{
2022-01-24 12:45:47 +00:00
const char char_names [ ] = " `-=[] \\ ,; \' ./ " ;
2022-01-05 15:54:03 +00:00
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 } ;
IM_ASSERT ( IM_ARRAYSIZE ( char_names ) = = IM_ARRAYSIZE ( char_keys ) ) ;
if ( key_name [ 0 ] > = ' 0 ' & & key_name [ 0 ] < = ' 9 ' ) { key = GLFW_KEY_0 + ( key_name [ 0 ] - ' 0 ' ) ; }
else if ( key_name [ 0 ] > = ' A ' & & key_name [ 0 ] < = ' Z ' ) { key = GLFW_KEY_A + ( key_name [ 0 ] - ' A ' ) ; }
else if ( const char * p = strchr ( char_names , key_name [ 0 ] ) ) { key = char_keys [ p - char_names ] ; }
}
// if (action == GLFW_PRESS) printf("key %d scancode %d name '%s'\n", key, scancode, key_name);
2022-01-14 04:47:53 +00:00
# else
IM_UNUSED ( scancode ) ;
2022-01-05 15:54:03 +00:00
# endif
2021-12-12 11:00:31 +00:00
return key ;
}
2022-01-05 15:54:03 +00:00
2021-12-12 11:00:31 +00:00
void ImGui_ImplGlfw_KeyCallback ( GLFWwindow * window , int keycode , int scancode , int action , int mods )
2018-02-16 20:38:38 +00:00
{
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 12:53:25 +00:00
if ( bd - > PrevUserCallbackKey ! = NULL & & window = = bd - > Window )
2021-12-12 11:00:31 +00:00
bd - > PrevUserCallbackKey ( window , keycode , scancode , action , mods ) ;
2018-11-08 15:24:41 +00:00
2021-12-12 11:00:31 +00:00
if ( action ! = GLFW_PRESS & & action ! = GLFW_RELEASE )
return ;
2018-02-16 20:38:38 +00:00
2022-01-17 13:57:55 +00:00
ImGui_ImplGlfw_UpdateKeyModifiers ( mods ) ;
2022-01-10 14:24:21 +00:00
if ( keycode > = 0 & & keycode < IM_ARRAYSIZE ( bd - > KeyOwnerWindows ) )
bd - > KeyOwnerWindows [ keycode ] = ( action = = GLFW_PRESS ) ? window : NULL ;
2021-12-12 11:00:31 +00:00
keycode = ImGui_ImplGlfw_TranslateUntranslatedKey ( keycode , scancode ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
ImGuiKey imgui_key = ImGui_ImplGlfw_KeyToImGuiKey ( keycode ) ;
io . AddKeyEvent ( imgui_key , ( action = = GLFW_PRESS ) ) ;
io . SetKeyEventNativeData ( imgui_key , keycode , scancode ) ; // To support legacy indexing (<1.87 user code)
2018-02-16 20:38:38 +00:00
}
2021-08-02 18:17:26 +00:00
void ImGui_ImplGlfw_WindowFocusCallback ( GLFWwindow * window , int focused )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
if ( bd - > PrevUserCallbackWindowFocus ! = NULL & & window = = bd - > Window )
bd - > PrevUserCallbackWindowFocus ( window , focused ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
io . AddFocusEvent ( focused ! = 0 ) ;
}
2022-01-12 16:08:37 +00:00
void ImGui_ImplGlfw_CursorPosCallback ( GLFWwindow * window , double x , double y )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
if ( bd - > PrevUserCallbackCursorPos ! = NULL & & window = = bd - > Window )
bd - > PrevUserCallbackCursorPos ( window , x , y ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-01-13 17:36:23 +00:00
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
{
int window_x , window_y ;
glfwGetWindowPos ( window , & window_x , & window_y ) ;
x + = window_x ;
y + = window_y ;
}
2022-01-17 16:22:37 +00:00
io . AddMousePosEvent ( ( float ) x , ( float ) y ) ;
2022-01-12 16:08:37 +00:00
}
2021-07-29 16:59:45 +00:00
void ImGui_ImplGlfw_CursorEnterCallback ( GLFWwindow * window , int entered )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-08-02 18:17:26 +00:00
if ( bd - > PrevUserCallbackCursorEnter ! = NULL & & window = = bd - > Window )
2021-07-29 16:59:45 +00:00
bd - > PrevUserCallbackCursorEnter ( window , entered ) ;
2021-08-02 18:17:26 +00:00
2022-01-12 16:08:37 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-07-29 16:59:45 +00:00
if ( entered )
bd - > MouseWindow = window ;
if ( ! entered & & bd - > MouseWindow = = window )
2022-01-12 16:08:37 +00:00
{
2021-07-29 16:59:45 +00:00
bd - > MouseWindow = NULL ;
2022-01-17 16:22:37 +00:00
io . AddMousePosEvent ( - FLT_MAX , - FLT_MAX ) ;
2022-01-12 16:08:37 +00:00
}
2021-07-29 16:59:45 +00:00
}
2018-11-08 15:24:41 +00:00
void ImGui_ImplGlfw_CharCallback ( GLFWwindow * window , unsigned int c )
2018-02-16 20:38:38 +00:00
{
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 12:53:25 +00:00
if ( bd - > PrevUserCallbackChar ! = NULL & & window = = bd - > Window )
2021-06-28 14:52:10 +00:00
bd - > PrevUserCallbackChar ( window , c ) ;
2018-11-08 15:24:41 +00:00
2018-02-16 20:38:38 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2019-05-11 08:33:56 +00:00
io . AddInputCharacter ( c ) ;
2018-02-16 20:38:38 +00:00
}
2020-02-09 16:31:18 +00:00
void ImGui_ImplGlfw_MonitorCallback ( GLFWmonitor * , int )
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
bd - > WantUpdateMonitors = true ;
2020-02-09 16:31:18 +00:00
}
2018-03-15 15:42:21 +00:00
static bool ImGui_ImplGlfw_Init ( GLFWwindow * window , bool install_callbacks , GlfwClientApi client_api )
2018-02-16 20:38:38 +00:00
{
2021-06-28 14:52:10 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
IM_ASSERT ( io . BackendPlatformUserData = = NULL & & " Already initialized a platform backend! " ) ;
2020-10-12 15:34:22 +00:00
// Setup backend capabilities flags
2021-06-30 13:22:15 +00:00
ImGui_ImplGlfw_Data * bd = IM_NEW ( ImGui_ImplGlfw_Data ) ( ) ;
2021-06-28 14:52:10 +00:00
io . BackendPlatformUserData = ( void * ) bd ;
io . BackendPlatformName = " imgui_impl_glfw " ;
2018-03-20 21:14:34 +00:00
io . BackendFlags | = ImGuiBackendFlags_HasMouseCursors ; // We can honor GetMouseCursor() values (optional)
2018-05-11 12:05:40 +00:00
io . BackendFlags | = ImGuiBackendFlags_HasSetMousePos ; // We can honor io.WantSetMousePos requests (optional, rarely used)
2018-03-20 21:14:34 +00:00
io . BackendFlags | = ImGuiBackendFlags_PlatformHasViewports ; // We can create multi-viewports on the Platform side (optional)
2020-07-17 13:57:50 +00:00
# if GLFW_HAS_MOUSE_PASSTHROUGH || (GLFW_HAS_WINDOW_HOVERED && defined(_WIN32))
2022-01-18 16:24:59 +00:00
io . BackendFlags | = ImGuiBackendFlags_HasMouseHoveredViewport ; // We can call io.AddMouseViewportEvent() with correct data (optional)
2018-03-20 21:14:34 +00:00
# endif
2021-06-30 13:22:15 +00:00
bd - > Window = window ;
bd - > Time = 0.0 ;
2021-07-09 18:16:19 +00:00
bd - > WantUpdateMonitors = true ;
2021-06-30 13:22:15 +00:00
2018-02-27 09:29:37 +00:00
io . SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText ;
io . GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText ;
2021-06-28 14:52:10 +00:00
io . ClipboardUserData = bd - > Window ;
2018-02-16 20:38:38 +00:00
2020-01-17 10:36:56 +00:00
// Create mouse cursors
// (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
// GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
// Missing cursors will return NULL and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
GLFWerrorfun prev_error_callback = glfwSetErrorCallback ( NULL ) ;
2021-06-28 14:52:10 +00:00
bd - > MouseCursors [ ImGuiMouseCursor_Arrow ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_TextInput ] = glfwCreateStandardCursor ( GLFW_IBEAM_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNS ] = glfwCreateStandardCursor ( GLFW_VRESIZE_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeEW ] = glfwCreateStandardCursor ( GLFW_HRESIZE_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_Hand ] = glfwCreateStandardCursor ( GLFW_HAND_CURSOR ) ;
2019-12-02 08:36:59 +00:00
# if GLFW_HAS_NEW_CURSORS
2021-06-28 14:52:10 +00:00
bd - > MouseCursors [ ImGuiMouseCursor_ResizeAll ] = glfwCreateStandardCursor ( GLFW_RESIZE_ALL_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNESW ] = glfwCreateStandardCursor ( GLFW_RESIZE_NESW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNWSE ] = glfwCreateStandardCursor ( GLFW_RESIZE_NWSE_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_NotAllowed ] = glfwCreateStandardCursor ( GLFW_NOT_ALLOWED_CURSOR ) ;
2019-12-02 08:36:59 +00:00
# else
2021-06-28 14:52:10 +00:00
bd - > MouseCursors [ ImGuiMouseCursor_ResizeAll ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNESW ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNWSE ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_NotAllowed ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
2019-12-02 08:36:59 +00:00
# endif
2020-01-17 10:36:56 +00:00
glfwSetErrorCallback ( prev_error_callback ) ;
2019-01-20 16:56:17 +00:00
2018-11-08 15:24:41 +00:00
// Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
2021-08-02 18:17:26 +00:00
bd - > PrevUserCallbackWindowFocus = NULL ;
2018-05-02 18:42:37 +00:00
bd - > PrevUserCallbackCursorEnter = NULL ;
2021-06-28 14:52:10 +00:00
bd - > PrevUserCallbackMousebutton = NULL ;
bd - > PrevUserCallbackScroll = NULL ;
bd - > PrevUserCallbackKey = NULL ;
bd - > PrevUserCallbackChar = NULL ;
2021-06-29 12:53:25 +00:00
bd - > PrevUserCallbackMonitor = NULL ;
2018-02-16 20:38:38 +00:00
if ( install_callbacks )
2018-11-08 15:06:22 +00:00
{
2021-06-28 14:52:10 +00:00
bd - > InstalledCallbacks = true ;
2021-08-02 18:17:26 +00:00
bd - > PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback ( window , ImGui_ImplGlfw_WindowFocusCallback ) ;
2021-07-29 16:59:45 +00:00
bd - > PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback ( window , ImGui_ImplGlfw_CursorEnterCallback ) ;
2022-01-12 16:08:37 +00:00
bd - > PrevUserCallbackCursorPos = glfwSetCursorPosCallback ( window , ImGui_ImplGlfw_CursorPosCallback ) ;
2021-06-28 14:52:10 +00:00
bd - > PrevUserCallbackMousebutton = glfwSetMouseButtonCallback ( window , ImGui_ImplGlfw_MouseButtonCallback ) ;
bd - > PrevUserCallbackScroll = glfwSetScrollCallback ( window , ImGui_ImplGlfw_ScrollCallback ) ;
bd - > PrevUserCallbackKey = glfwSetKeyCallback ( window , ImGui_ImplGlfw_KeyCallback ) ;
bd - > PrevUserCallbackChar = glfwSetCharCallback ( window , ImGui_ImplGlfw_CharCallback ) ;
2021-06-29 12:53:25 +00:00
bd - > PrevUserCallbackMonitor = glfwSetMonitorCallback ( ImGui_ImplGlfw_MonitorCallback ) ;
2018-11-08 15:06:22 +00:00
}
2018-02-16 20:38:38 +00:00
2020-02-09 16:31:18 +00:00
// Update monitors the first time (note: monitor callback are broken in GLFW 3.2 and earlier, see github.com/glfw/glfw/issues/784)
ImGui_ImplGlfw_UpdateMonitors ( ) ;
glfwSetMonitorCallback ( ImGui_ImplGlfw_MonitorCallback ) ;
2018-02-27 22:27:41 +00:00
// Our mouse update function expect PlatformHandle to be filled for the main viewport
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2021-06-29 12:53:25 +00:00
main_viewport - > PlatformHandle = ( void * ) bd - > Window ;
2019-06-18 21:35:48 +00:00
# ifdef _WIN32
2021-06-29 12:53:25 +00:00
main_viewport - > PlatformHandleRaw = glfwGetWin32Window ( bd - > Window ) ;
2019-06-18 21:35:48 +00:00
# endif
2018-04-10 17:21:52 +00:00
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
2018-02-27 22:27:41 +00:00
ImGui_ImplGlfw_InitPlatformInterface ( ) ;
2021-06-28 14:52:10 +00:00
bd - > ClientApi = client_api ;
2018-03-02 18:23:01 +00:00
return true ;
}
2018-03-15 15:42:21 +00:00
bool ImGui_ImplGlfw_InitForOpenGL ( GLFWwindow * window , bool install_callbacks )
{
return ImGui_ImplGlfw_Init ( window , install_callbacks , GlfwClientApi_OpenGL ) ;
}
2018-03-02 18:23:01 +00:00
bool ImGui_ImplGlfw_InitForVulkan ( GLFWwindow * window , bool install_callbacks )
{
2018-03-15 15:42:21 +00:00
return ImGui_ImplGlfw_Init ( window , install_callbacks , GlfwClientApi_Vulkan ) ;
2018-02-16 20:38:38 +00:00
}
2021-02-10 16:27:33 +00:00
bool ImGui_ImplGlfw_InitForOther ( GLFWwindow * window , bool install_callbacks )
2021-01-28 11:11:26 +00:00
{
2021-02-10 16:27:33 +00:00
return ImGui_ImplGlfw_Init ( window , install_callbacks , GlfwClientApi_Unknown ) ;
2021-01-28 11:11:26 +00:00
}
2018-02-16 20:38:38 +00:00
void ImGui_ImplGlfw_Shutdown ( )
{
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-09-20 16:43:05 +00:00
IM_ASSERT ( bd ! = NULL & & " No platform backend to shutdown, or already shutdown? " ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 14:52:10 +00:00
2018-02-27 22:27:41 +00:00
ImGui_ImplGlfw_ShutdownPlatformInterface ( ) ;
2021-06-28 14:52:10 +00:00
if ( bd - > InstalledCallbacks )
2019-10-18 14:25:18 +00:00
{
2021-08-02 18:17:26 +00:00
glfwSetWindowFocusCallback ( bd - > Window , bd - > PrevUserCallbackWindowFocus ) ;
2021-08-02 13:04:45 +00:00
glfwSetCursorEnterCallback ( bd - > Window , bd - > PrevUserCallbackCursorEnter ) ;
2022-01-12 16:08:37 +00:00
glfwSetCursorPosCallback ( bd - > Window , bd - > PrevUserCallbackCursorPos ) ;
2021-06-28 14:52:10 +00:00
glfwSetMouseButtonCallback ( bd - > Window , bd - > PrevUserCallbackMousebutton ) ;
glfwSetScrollCallback ( bd - > Window , bd - > PrevUserCallbackScroll ) ;
glfwSetKeyCallback ( bd - > Window , bd - > PrevUserCallbackKey ) ;
glfwSetCharCallback ( bd - > Window , bd - > PrevUserCallbackChar ) ;
2021-07-07 12:12:48 +00:00
glfwSetMonitorCallback ( bd - > PrevUserCallbackMonitor ) ;
2019-10-18 14:25:18 +00:00
}
2018-06-20 09:06:29 +00:00
for ( ImGuiMouseCursor cursor_n = 0 ; cursor_n < ImGuiMouseCursor_COUNT ; cursor_n + + )
2021-06-28 14:52:10 +00:00
glfwDestroyCursor ( bd - > MouseCursors [ cursor_n ] ) ;
io . BackendPlatformName = NULL ;
io . BackendPlatformUserData = NULL ;
2021-06-30 13:22:15 +00:00
IM_DELETE ( bd ) ;
2018-02-16 20:38:38 +00:00
}
2022-01-12 16:08:37 +00:00
static void ImGui_ImplGlfw_UpdateMouseData ( )
2018-02-16 20:38:38 +00:00
{
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2019-06-06 14:16:18 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-08-02 13:04:45 +00:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
2022-01-18 16:24:59 +00:00
ImGuiID mouse_viewport_id = 0 ;
2022-01-13 17:36:23 +00:00
const ImVec2 mouse_pos_prev = io . MousePos ;
2018-04-10 20:58:39 +00:00
for ( int n = 0 ; n < platform_io . Viewports . Size ; n + + )
2018-02-16 20:38:38 +00:00
{
2018-04-10 20:58:39 +00:00
ImGuiViewport * viewport = platform_io . Viewports [ n ] ;
2018-02-27 22:27:41 +00:00
GLFWwindow * window = ( GLFWwindow * ) viewport - > PlatformHandle ;
2021-08-02 13:04:45 +00:00
2018-08-01 09:34:17 +00:00
# ifdef __EMSCRIPTEN__
2022-01-13 17:36:23 +00:00
const bool is_window_focused = true ;
2018-08-01 09:34:17 +00:00
# else
2022-01-13 17:36:23 +00:00
const bool is_window_focused = glfwGetWindowAttrib ( window , GLFW_FOCUSED ) ! = 0 ;
2018-08-01 09:34:17 +00:00
# endif
2022-01-13 17:36:23 +00:00
if ( is_window_focused )
2022-01-12 16:08:37 +00:00
{
2022-01-13 17:36:23 +00:00
// (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
// When multi-viewports are enabled, all Dear ImGui positions are same as OS positions.
if ( io . WantSetMousePos )
glfwSetCursorPos ( window , ( double ) ( mouse_pos_prev . x - viewport - > Pos . x ) , ( double ) ( mouse_pos_prev . y - viewport - > Pos . y ) ) ;
2021-08-02 13:04:45 +00:00
2022-01-13 17:36:23 +00:00
// (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
if ( bd - > MouseWindow = = NULL )
2018-05-11 12:05:40 +00:00
{
2022-01-13 17:36:23 +00:00
double mouse_x , mouse_y ;
glfwGetCursorPos ( window , & mouse_x , & mouse_y ) ;
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
{
// 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)
// 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)
int window_x , window_y ;
glfwGetWindowPos ( window , & window_x , & window_y ) ;
mouse_x + = window_x ;
mouse_y + = window_y ;
}
2022-01-17 17:16:55 +00:00
io . AddMousePosEvent ( ( float ) mouse_x , ( float ) mouse_y ) ;
2018-05-11 12:05:40 +00:00
}
2018-02-16 20:38:38 +00:00
}
2018-02-27 22:27:41 +00:00
2022-01-18 16:24:59 +00:00
// (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
2022-01-18 15:59:19 +00:00
// If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
// - [X] GLFW >= 3.3 backend ON WINDOWS ONLY does correctly ignore viewports with the _NoInputs flag.
// - [!] GLFW <= 3.2 backend CANNOT correctly ignore viewports with the _NoInputs flag, and CANNOT reported Hovered Viewport because of mouse capture.
// 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
// 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
// by the backend, and use its flawed heuristic to guess the viewport behind.
// - [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).
// FIXME: This is currently only correct on Win32. See what we do below with the WM_NCHITTEST, missing an equivalent for other systems.
2018-12-06 15:30:10 +00:00
// See https://github.com/glfw/glfw/issues/1236 if you want to help in making this a GLFW feature.
2020-07-17 13:57:50 +00:00
# if GLFW_HAS_MOUSE_PASSTHROUGH || (GLFW_HAS_WINDOW_HOVERED && defined(_WIN32))
const bool window_no_input = ( viewport - > Flags & ImGuiViewportFlags_NoInputs ) ! = 0 ;
# if GLFW_HAS_MOUSE_PASSTHROUGH
glfwSetWindowAttrib ( window , GLFW_MOUSE_PASSTHROUGH , window_no_input ) ;
# endif
if ( glfwGetWindowAttrib ( window , GLFW_HOVERED ) & & ! window_no_input )
2022-01-18 16:24:59 +00:00
mouse_viewport_id = viewport - > ID ;
2022-01-18 15:59:19 +00:00
# else
// We cannot use bd->MouseWindow maintained from CursorEnter/Leave callbacks, because it is locked to the window capturing mouse.
2018-02-27 22:27:41 +00:00
# endif
}
2022-01-18 16:24:59 +00:00
if ( io . BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport )
io . AddMouseViewportEvent ( mouse_viewport_id ) ;
2018-05-11 14:41:32 +00:00
}
static void ImGui_ImplGlfw_UpdateMouseCursor ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
if ( ( io . ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange ) | | glfwGetInputMode ( bd - > Window , GLFW_CURSOR ) = = GLFW_CURSOR_DISABLED )
2018-05-11 14:41:32 +00:00
return ;
2018-02-27 22:27:41 +00:00
2018-05-11 14:41:32 +00:00
ImGuiMouseCursor imgui_cursor = ImGui : : GetMouseCursor ( ) ;
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
for ( int n = 0 ; n < platform_io . Viewports . Size ; n + + )
2018-02-16 20:38:38 +00:00
{
2018-05-11 14:41:32 +00:00
GLFWwindow * window = ( GLFWwindow * ) platform_io . Viewports [ n ] - > PlatformHandle ;
if ( imgui_cursor = = ImGuiMouseCursor_None | | io . MouseDrawCursor )
2018-03-20 21:14:34 +00:00
{
2018-05-11 14:41:32 +00:00
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
glfwSetInputMode ( window , GLFW_CURSOR , GLFW_CURSOR_HIDDEN ) ;
}
else
{
// Show OS mouse cursor
// FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
2021-06-29 12:53:25 +00:00
glfwSetCursor ( window , bd - > MouseCursors [ imgui_cursor ] ? bd - > MouseCursors [ imgui_cursor ] : bd - > MouseCursors [ ImGuiMouseCursor_Arrow ] ) ;
2018-05-11 14:41:32 +00:00
glfwSetInputMode ( window , GLFW_CURSOR , GLFW_CURSOR_NORMAL ) ;
2018-03-20 21:14:34 +00:00
}
2018-02-16 20:38:38 +00:00
}
2018-02-27 09:29:37 +00:00
}
2022-01-20 16:12:22 +00:00
// Update gamepad inputs
static inline float Saturate ( float v ) { return v < 0.0f ? 0.0f : v > 1.0f ? 1.0f : v ; }
2019-02-14 17:55:08 +00:00
static void ImGui_ImplGlfw_UpdateGamepads ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
if ( ( io . ConfigFlags & ImGuiConfigFlags_NavEnableGamepad ) = = 0 )
return ;
2022-01-20 16:12:22 +00:00
io . BackendFlags & = ~ ImGuiBackendFlags_HasGamepad ;
# if GLFW_HAS_GAMEPAD_API
GLFWgamepadstate gamepad ;
if ( ! glfwGetGamepadState ( GLFW_JOYSTICK_1 , & gamepad ) )
return ;
2022-01-20 16:39:25 +00:00
# define MAP_BUTTON(KEY_NO, BUTTON_NO, _UNUSED) do { io.AddKeyEvent(KEY_NO, gamepad.buttons[BUTTON_NO] != 0); } while (0)
# 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)
2022-01-20 16:12:22 +00:00
# else
2019-02-14 17:55:08 +00:00
int axes_count = 0 , buttons_count = 0 ;
const float * axes = glfwGetJoystickAxes ( GLFW_JOYSTICK_1 , & axes_count ) ;
const unsigned char * buttons = glfwGetJoystickButtons ( GLFW_JOYSTICK_1 , & buttons_count ) ;
2022-01-20 16:12:22 +00:00
if ( axes_count = = 0 | | buttons_count = = 0 )
return ;
2022-01-20 16:39:25 +00:00
# define MAP_BUTTON(KEY_NO, _UNUSED, BUTTON_NO) do { io.AddKeyEvent(KEY_NO, (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS)); } while (0)
# 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)
2022-01-20 16:12:22 +00:00
# endif
io . BackendFlags | = ImGuiBackendFlags_HasGamepad ;
MAP_BUTTON ( ImGuiKey_GamepadStart , GLFW_GAMEPAD_BUTTON_START , 7 ) ;
MAP_BUTTON ( ImGuiKey_GamepadBack , GLFW_GAMEPAD_BUTTON_BACK , 6 ) ;
MAP_BUTTON ( ImGuiKey_GamepadFaceDown , GLFW_GAMEPAD_BUTTON_A , 0 ) ; // Xbox A, PS Cross
MAP_BUTTON ( ImGuiKey_GamepadFaceRight , GLFW_GAMEPAD_BUTTON_B , 1 ) ; // Xbox B, PS Circle
MAP_BUTTON ( ImGuiKey_GamepadFaceLeft , GLFW_GAMEPAD_BUTTON_X , 2 ) ; // Xbox X, PS Square
MAP_BUTTON ( ImGuiKey_GamepadFaceUp , GLFW_GAMEPAD_BUTTON_Y , 3 ) ; // Xbox Y, PS Triangle
MAP_BUTTON ( ImGuiKey_GamepadDpadLeft , GLFW_GAMEPAD_BUTTON_DPAD_LEFT , 13 ) ;
MAP_BUTTON ( ImGuiKey_GamepadDpadRight , GLFW_GAMEPAD_BUTTON_DPAD_RIGHT , 11 ) ;
MAP_BUTTON ( ImGuiKey_GamepadDpadUp , GLFW_GAMEPAD_BUTTON_DPAD_UP , 10 ) ;
MAP_BUTTON ( ImGuiKey_GamepadDpadDown , GLFW_GAMEPAD_BUTTON_DPAD_DOWN , 12 ) ;
MAP_BUTTON ( ImGuiKey_GamepadL1 , GLFW_GAMEPAD_BUTTON_LEFT_BUMPER , 4 ) ;
MAP_BUTTON ( ImGuiKey_GamepadR1 , GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER , 5 ) ;
MAP_ANALOG ( ImGuiKey_GamepadL2 , GLFW_GAMEPAD_AXIS_LEFT_TRIGGER , 4 , - 0.75f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadR2 , GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER , 5 , - 0.75f , + 1.0f ) ;
MAP_BUTTON ( ImGuiKey_GamepadL3 , GLFW_GAMEPAD_BUTTON_LEFT_THUMB , 8 ) ;
MAP_BUTTON ( ImGuiKey_GamepadR3 , GLFW_GAMEPAD_BUTTON_RIGHT_THUMB , 9 ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickLeft , GLFW_GAMEPAD_AXIS_LEFT_X , 0 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickRight , GLFW_GAMEPAD_AXIS_LEFT_X , 0 , + 0.25f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickUp , GLFW_GAMEPAD_AXIS_LEFT_Y , 1 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickDown , GLFW_GAMEPAD_AXIS_LEFT_Y , 1 , + 0.25f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickLeft , GLFW_GAMEPAD_AXIS_RIGHT_X , 2 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickRight , GLFW_GAMEPAD_AXIS_RIGHT_X , 2 , + 0.25f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickUp , GLFW_GAMEPAD_AXIS_RIGHT_Y , 3 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickDown , GLFW_GAMEPAD_AXIS_RIGHT_Y , 3 , + 0.25f , + 1.0f ) ;
2019-02-14 17:55:08 +00:00
# undef MAP_BUTTON
# undef MAP_ANALOG
}
2020-02-09 16:31:18 +00:00
static void ImGui_ImplGlfw_UpdateMonitors ( )
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2020-02-09 16:31:18 +00:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
int monitors_count = 0 ;
GLFWmonitor * * glfw_monitors = glfwGetMonitors ( & monitors_count ) ;
platform_io . Monitors . resize ( 0 ) ;
for ( int n = 0 ; n < monitors_count ; n + + )
{
ImGuiPlatformMonitor monitor ;
int x , y ;
glfwGetMonitorPos ( glfw_monitors [ n ] , & x , & y ) ;
const GLFWvidmode * vid_mode = glfwGetVideoMode ( glfw_monitors [ n ] ) ;
2020-09-04 15:26:31 +00:00
monitor . MainPos = monitor . WorkPos = ImVec2 ( ( float ) x , ( float ) y ) ;
monitor . MainSize = monitor . WorkSize = ImVec2 ( ( float ) vid_mode - > width , ( float ) vid_mode - > height ) ;
2020-02-09 16:31:18 +00:00
# if GLFW_HAS_MONITOR_WORK_AREA
int w , h ;
glfwGetMonitorWorkarea ( glfw_monitors [ n ] , & x , & y , & w , & h ) ;
2020-09-04 15:26:31 +00:00
if ( w > 0 & & h > 0 ) // Workaround a small GLFW issue reporting zero on monitor changes: https://github.com/glfw/glfw/pull/1761
{
monitor . WorkPos = ImVec2 ( ( float ) x , ( float ) y ) ;
monitor . WorkSize = ImVec2 ( ( float ) w , ( float ) h ) ;
}
2020-02-09 16:31:18 +00:00
# endif
# if GLFW_HAS_PER_MONITOR_DPI
// 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.
float x_scale , y_scale ;
glfwGetMonitorContentScale ( glfw_monitors [ n ] , & x_scale , & y_scale ) ;
monitor . DpiScale = x_scale ;
# endif
platform_io . Monitors . push_back ( monitor ) ;
}
2021-06-29 12:53:25 +00:00
bd - > WantUpdateMonitors = false ;
2020-02-09 16:31:18 +00:00
}
2018-02-27 09:29:37 +00:00
void ImGui_ImplGlfw_NewFrame ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 14:52:10 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 15:53:41 +00:00
IM_ASSERT ( bd ! = NULL & & " Did you call ImGui_ImplGlfw_InitForXXX()? " ) ;
2018-02-27 09:29:37 +00:00
2018-12-23 16:39:04 +00:00
// Setup display size (every frame to accommodate for window resizing)
2018-02-27 09:29:37 +00:00
int w , h ;
int display_w , display_h ;
2021-06-28 14:52:10 +00:00
glfwGetWindowSize ( bd - > Window , & w , & h ) ;
glfwGetFramebufferSize ( bd - > Window , & display_w , & display_h ) ;
2018-02-27 09:29:37 +00:00
io . DisplaySize = ImVec2 ( ( float ) w , ( float ) h ) ;
2019-03-12 17:27:14 +00:00
if ( w > 0 & & h > 0 )
2021-12-29 11:41:34 +00:00
io . DisplayFramebufferScale = ImVec2 ( ( float ) display_w / ( float ) w , ( float ) display_h / ( float ) h ) ;
2021-06-29 12:53:25 +00:00
if ( bd - > WantUpdateMonitors )
2018-04-26 14:07:54 +00:00
ImGui_ImplGlfw_UpdateMonitors ( ) ;
2018-02-27 09:29:37 +00:00
// Setup time step
2018-02-27 22:27:41 +00:00
double current_time = glfwGetTime ( ) ;
2021-06-28 14:52:10 +00:00
io . DeltaTime = bd - > Time > 0.0 ? ( float ) ( current_time - bd - > Time ) : ( float ) ( 1.0f / 60.0f ) ;
bd - > Time = current_time ;
2018-02-27 09:29:37 +00:00
2022-01-12 16:08:37 +00:00
ImGui_ImplGlfw_UpdateMouseData ( ) ;
2018-05-11 14:41:32 +00:00
ImGui_ImplGlfw_UpdateMouseCursor ( ) ;
2018-02-16 20:38:38 +00:00
2019-04-23 10:26:14 +00:00
// Update game controllers (if enabled and available)
2019-02-14 17:55:08 +00:00
ImGui_ImplGlfw_UpdateGamepads ( ) ;
2018-02-16 20:38:38 +00:00
}
2018-02-27 22:27:41 +00:00
2018-04-24 15:09:50 +00:00
//--------------------------------------------------------------------------------------------------------
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
2020-10-14 12:43:45 +00:00
// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
2018-04-24 15:09:50 +00:00
// 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..
//--------------------------------------------------------------------------------------------------------
2018-02-27 22:27:41 +00:00
2020-01-20 18:33:46 +00:00
// Helper structure we store in the void* RenderUserData field of each ImGuiViewport to easily retrieve our backend data.
2021-06-29 13:34:54 +00:00
struct ImGui_ImplGlfw_ViewportData
2018-02-27 22:27:41 +00:00
{
GLFWwindow * Window ;
bool WindowOwned ;
2020-04-15 12:00:37 +00:00
int IgnoreWindowPosEventFrame ;
2019-08-29 13:53:33 +00:00
int IgnoreWindowSizeEventFrame ;
2018-02-27 22:27:41 +00:00
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData ( ) { Window = NULL ; WindowOwned = false ; IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = - 1 ; }
~ ImGui_ImplGlfw_ViewportData ( ) { IM_ASSERT ( Window = = NULL ) ; }
2018-02-27 22:27:41 +00:00
} ;
2018-03-15 09:54:27 +00:00
static void ImGui_ImplGlfw_WindowCloseCallback ( GLFWwindow * window )
{
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( window ) )
viewport - > PlatformRequestClose = true ;
}
2020-04-15 12:00:37 +00:00
// GLFW may dispatch window pos/size events after calling glfwSetWindowPos()/glfwSetWindowSize().
// However: depending on the platform the callback may be invoked at different time:
// - on Windows it appears to be called within the glfwSetWindowPos()/glfwSetWindowSize() call
// - on Linux it is queued and invoked during glfwPollEvents()
// Because the event doesn't always fire on glfwSetWindowXXX() we use a frame counter tag to only
// ignore recent glfwSetWindowXXX() calls.
2018-03-15 09:54:27 +00:00
static void ImGui_ImplGlfw_WindowPosCallback ( GLFWwindow * window , int , int )
{
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( window ) )
2020-04-15 12:00:37 +00:00
{
2021-06-29 13:34:54 +00:00
if ( ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData )
2020-04-15 12:00:37 +00:00
{
2021-06-29 13:34:54 +00:00
bool ignore_event = ( ImGui : : GetFrameCount ( ) < = vd - > IgnoreWindowPosEventFrame + 1 ) ;
2020-04-15 12:00:37 +00:00
//data->IgnoreWindowPosEventFrame = -1;
if ( ignore_event )
return ;
}
2018-03-15 09:54:27 +00:00
viewport - > PlatformRequestMove = true ;
2020-04-15 12:00:37 +00:00
}
2018-03-15 09:54:27 +00:00
}
static void ImGui_ImplGlfw_WindowSizeCallback ( GLFWwindow * window , int , int )
{
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( window ) )
2019-08-23 13:12:06 +00:00
{
2021-06-29 13:34:54 +00:00
if ( ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData )
2019-08-23 13:12:06 +00:00
{
2021-06-29 13:34:54 +00:00
bool ignore_event = ( ImGui : : GetFrameCount ( ) < = vd - > IgnoreWindowSizeEventFrame + 1 ) ;
2020-04-15 12:00:37 +00:00
//data->IgnoreWindowSizeEventFrame = -1;
2019-08-29 13:53:33 +00:00
if ( ignore_event )
2019-08-23 13:12:06 +00:00
return ;
}
2018-03-15 09:54:27 +00:00
viewport - > PlatformRequestResize = true ;
2019-08-23 13:12:06 +00:00
}
2018-03-15 09:54:27 +00:00
}
2018-03-18 17:44:57 +00:00
static void ImGui_ImplGlfw_CreateWindow ( ImGuiViewport * viewport )
2018-02-27 22:27:41 +00:00
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = IM_NEW ( ImGui_ImplGlfw_ViewportData ) ( ) ;
viewport - > PlatformUserData = vd ;
2018-02-27 22:27:41 +00:00
// GLFW 3.2 unfortunately always set focus on glfwCreateWindow() if GLFW_VISIBLE is set, regardless of GLFW_FOCUSED
2019-05-11 08:54:56 +00:00
// With GLFW 3.3, the hint GLFW_FOCUS_ON_SHOW fixes this problem
2018-02-27 22:27:41 +00:00
glfwWindowHint ( GLFW_VISIBLE , false ) ;
glfwWindowHint ( GLFW_FOCUSED , false ) ;
2019-05-11 08:54:56 +00:00
# if GLFW_HAS_FOCUS_ON_SHOW
2021-02-18 11:53:15 +00:00
glfwWindowHint ( GLFW_FOCUS_ON_SHOW , false ) ;
2019-05-11 08:54:56 +00:00
# endif
2018-02-27 22:27:41 +00:00
glfwWindowHint ( GLFW_DECORATED , ( viewport - > Flags & ImGuiViewportFlags_NoDecoration ) ? false : true ) ;
2018-04-11 19:27:19 +00:00
# if GLFW_HAS_WINDOW_TOPMOST
2018-05-10 10:10:10 +00:00
glfwWindowHint ( GLFW_FLOATING , ( viewport - > Flags & ImGuiViewportFlags_TopMost ) ? true : false ) ;
2018-04-11 19:27:19 +00:00
# endif
2021-06-29 12:53:25 +00:00
GLFWwindow * share_window = ( bd - > ClientApi = = GlfwClientApi_OpenGL ) ? bd - > Window : NULL ;
2021-06-29 13:34:54 +00:00
vd - > Window = glfwCreateWindow ( ( int ) viewport - > Size . x , ( int ) viewport - > Size . y , " No Title Yet " , NULL , share_window ) ;
vd - > WindowOwned = true ;
viewport - > PlatformHandle = ( void * ) vd - > Window ;
2019-06-18 21:35:48 +00:00
# ifdef _WIN32
2021-06-29 13:34:54 +00:00
viewport - > PlatformHandleRaw = glfwGetWin32Window ( vd - > Window ) ;
2019-06-18 21:35:48 +00:00
# endif
2021-06-29 13:34:54 +00:00
glfwSetWindowPos ( vd - > Window , ( int ) viewport - > Pos . x , ( int ) viewport - > Pos . y ) ;
2018-11-08 15:56:51 +00:00
2020-01-20 18:33:46 +00:00
// Install GLFW callbacks for secondary viewports
2021-08-19 15:25:12 +00:00
glfwSetWindowFocusCallback ( vd - > Window , ImGui_ImplGlfw_WindowFocusCallback ) ;
2021-08-02 13:04:45 +00:00
glfwSetCursorEnterCallback ( vd - > Window , ImGui_ImplGlfw_CursorEnterCallback ) ;
2022-01-13 17:36:23 +00:00
glfwSetCursorPosCallback ( vd - > Window , ImGui_ImplGlfw_CursorPosCallback ) ;
2021-06-29 13:34:54 +00:00
glfwSetMouseButtonCallback ( vd - > Window , ImGui_ImplGlfw_MouseButtonCallback ) ;
glfwSetScrollCallback ( vd - > Window , ImGui_ImplGlfw_ScrollCallback ) ;
glfwSetKeyCallback ( vd - > Window , ImGui_ImplGlfw_KeyCallback ) ;
glfwSetCharCallback ( vd - > Window , ImGui_ImplGlfw_CharCallback ) ;
glfwSetWindowCloseCallback ( vd - > Window , ImGui_ImplGlfw_WindowCloseCallback ) ;
glfwSetWindowPosCallback ( vd - > Window , ImGui_ImplGlfw_WindowPosCallback ) ;
glfwSetWindowSizeCallback ( vd - > Window , ImGui_ImplGlfw_WindowSizeCallback ) ;
2021-06-29 12:53:25 +00:00
if ( bd - > ClientApi = = GlfwClientApi_OpenGL )
2018-08-25 18:15:18 +00:00
{
2021-06-29 13:34:54 +00:00
glfwMakeContextCurrent ( vd - > Window ) ;
2018-08-25 18:15:18 +00:00
glfwSwapInterval ( 0 ) ;
}
2018-02-27 22:27:41 +00:00
}
2018-03-18 17:44:57 +00:00
static void ImGui_ImplGlfw_DestroyWindow ( ImGuiViewport * viewport )
2018-02-27 22:27:41 +00:00
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 13:34:54 +00:00
if ( ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData )
2018-02-27 22:27:41 +00:00
{
2021-06-29 13:34:54 +00:00
if ( vd - > WindowOwned )
2018-04-09 20:01:24 +00:00
{
2020-07-17 13:57:50 +00:00
# if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
2019-06-18 21:35:48 +00:00
HWND hwnd = ( HWND ) viewport - > PlatformHandleRaw ;
2018-04-09 20:01:24 +00:00
: : RemovePropA ( hwnd , " IMGUI_VIEWPORT " ) ;
# endif
2021-03-08 08:25:07 +00:00
// Release any keys that were pressed in the window being destroyed and are still held down,
// because we will not receive any release events after window is destroyed.
2021-06-29 12:53:25 +00:00
for ( int i = 0 ; i < IM_ARRAYSIZE ( bd - > KeyOwnerWindows ) ; i + + )
2021-06-29 13:34:54 +00:00
if ( bd - > KeyOwnerWindows [ i ] = = vd - > Window )
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.
2021-03-08 08:25:07 +00:00
2021-06-29 13:34:54 +00:00
glfwDestroyWindow ( vd - > Window ) ;
2018-04-09 20:01:24 +00:00
}
2021-06-29 13:34:54 +00:00
vd - > Window = NULL ;
IM_DELETE ( vd ) ;
2018-02-27 22:27:41 +00:00
}
viewport - > PlatformUserData = viewport - > PlatformHandle = NULL ;
}
2020-01-20 18:33:46 +00:00
// We have submitted https://github.com/glfw/glfw/pull/1568 to allow GLFW to support "transparent inputs".
// In the meanwhile we implement custom per-platform workarounds here (FIXME-VIEWPORT: Implement same work-around for Linux/OSX!)
2020-07-17 13:57:50 +00:00
# if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
2018-02-27 22:27:41 +00:00
static WNDPROC g_GlfwWndProc = NULL ;
static LRESULT CALLBACK WndProcNoInputs ( HWND hWnd , UINT msg , WPARAM wParam , LPARAM lParam )
{
if ( msg = = WM_NCHITTEST )
{
2022-01-18 16:24:59 +00:00
// Let mouse pass-through the window. This will allow the backend to call io.AddMouseViewportEvent() properly (which is OPTIONAL).
2018-04-05 10:00:07 +00:00
// The ImGuiViewportFlags_NoInputs flag is set while dragging a viewport, as want to detect the window behind the one we are dragging.
// If you cannot easily access those viewport flags from your windowing/event code: you may manually synchronize its state e.g. in
2020-03-06 16:53:09 +00:00
// your main loop after calling UpdatePlatformWindows(). Iterate all viewports/platform windows and pass the flag to your windowing system.
2018-02-27 22:27:41 +00:00
ImGuiViewport * viewport = ( ImGuiViewport * ) : : GetPropA ( hWnd , " IMGUI_VIEWPORT " ) ;
if ( viewport - > Flags & ImGuiViewportFlags_NoInputs )
return HTTRANSPARENT ;
}
return : : CallWindowProc ( g_GlfwWndProc , hWnd , msg , wParam , lParam ) ;
}
# endif
static void ImGui_ImplGlfw_ShowWindow ( ImGuiViewport * viewport )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2018-02-27 22:27:41 +00:00
# if defined(_WIN32)
// GLFW hack: Hide icon from task bar
2019-06-18 21:35:48 +00:00
HWND hwnd = ( HWND ) viewport - > PlatformHandleRaw ;
2018-04-10 17:15:44 +00:00
if ( viewport - > Flags & ImGuiViewportFlags_NoTaskBarIcon )
2018-02-27 22:27:41 +00:00
{
LONG ex_style = : : GetWindowLong ( hwnd , GWL_EXSTYLE ) ;
ex_style & = ~ WS_EX_APPWINDOW ;
ex_style | = WS_EX_TOOLWINDOW ;
: : SetWindowLong ( hwnd , GWL_EXSTYLE , ex_style ) ;
}
// GLFW hack: install hook for WM_NCHITTEST message handler
2020-07-17 13:57:50 +00:00
# if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
2018-02-27 22:27:41 +00:00
: : SetPropA ( hwnd , " IMGUI_VIEWPORT " , viewport ) ;
if ( g_GlfwWndProc = = NULL )
g_GlfwWndProc = ( WNDPROC ) : : GetWindowLongPtr ( hwnd , GWLP_WNDPROC ) ;
: : SetWindowLongPtr ( hwnd , GWLP_WNDPROC , ( LONG_PTR ) WndProcNoInputs ) ;
# endif
2019-05-11 08:54:56 +00:00
# if !GLFW_HAS_FOCUS_ON_SHOW
2018-02-27 22:27:41 +00:00
// GLFW hack: GLFW 3.2 has a bug where glfwShowWindow() also activates/focus the window.
2019-02-19 15:36:06 +00:00
// 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.
// See https://github.com/glfw/glfw/issues/1189
// FIXME-VIEWPORT: Implement same work-around for Linux/OSX in the meanwhile.
2018-02-27 22:27:41 +00:00
if ( viewport - > Flags & ImGuiViewportFlags_NoFocusOnAppearing )
{
: : ShowWindow ( hwnd , SW_SHOWNA ) ;
return ;
}
2019-05-11 08:54:56 +00:00
# endif
2018-02-27 22:27:41 +00:00
# endif
2021-06-29 13:34:54 +00:00
glfwShowWindow ( vd - > Window ) ;
2018-02-27 22:27:41 +00:00
}
static ImVec2 ImGui_ImplGlfw_GetWindowPos ( ImGuiViewport * viewport )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2018-02-27 22:27:41 +00:00
int x = 0 , y = 0 ;
2021-06-29 13:34:54 +00:00
glfwGetWindowPos ( vd - > Window , & x , & y ) ;
2018-02-27 22:27:41 +00:00
return ImVec2 ( ( float ) x , ( float ) y ) ;
}
static void ImGui_ImplGlfw_SetWindowPos ( ImGuiViewport * viewport , ImVec2 pos )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
vd - > IgnoreWindowPosEventFrame = ImGui : : GetFrameCount ( ) ;
glfwSetWindowPos ( vd - > Window , ( int ) pos . x , ( int ) pos . y ) ;
2018-02-27 22:27:41 +00:00
}
static ImVec2 ImGui_ImplGlfw_GetWindowSize ( ImGuiViewport * viewport )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2018-02-27 22:27:41 +00:00
int w = 0 , h = 0 ;
2021-06-29 13:34:54 +00:00
glfwGetWindowSize ( vd - > Window , & w , & h ) ;
2018-02-27 22:27:41 +00:00
return ImVec2 ( ( float ) w , ( float ) h ) ;
}
static void ImGui_ImplGlfw_SetWindowSize ( ImGuiViewport * viewport , ImVec2 size )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2020-03-26 07:42:04 +00:00
# if __APPLE__ && !GLFW_HAS_OSX_WINDOW_POS_FIX
2019-08-29 11:02:42 +00:00
// Native OS windows are positioned from the bottom-left corner on macOS, whereas on other platforms they are
// positioned from the upper-left corner. GLFW makes an effort to convert macOS style coordinates, however it
// doesn't handle it when changing size. We are manually moving the window in order for changes of size to be based
// on the upper-left corner.
int x , y , width , height ;
2021-06-29 13:34:54 +00:00
glfwGetWindowPos ( vd - > Window , & x , & y ) ;
glfwGetWindowSize ( vd - > Window , & width , & height ) ;
glfwSetWindowPos ( vd - > Window , x , y - height + size . y ) ;
2019-08-29 11:02:42 +00:00
# endif
2021-06-29 13:34:54 +00:00
vd - > IgnoreWindowSizeEventFrame = ImGui : : GetFrameCount ( ) ;
glfwSetWindowSize ( vd - > Window , ( int ) size . x , ( int ) size . y ) ;
2018-02-27 22:27:41 +00:00
}
static void ImGui_ImplGlfw_SetWindowTitle ( ImGuiViewport * viewport , const char * title )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
glfwSetWindowTitle ( vd - > Window , title ) ;
2018-02-27 22:27:41 +00:00
}
2018-04-25 13:15:14 +00:00
static void ImGui_ImplGlfw_SetWindowFocus ( ImGuiViewport * viewport )
{
2018-09-20 16:46:36 +00:00
# if GLFW_HAS_FOCUS_WINDOW
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
glfwFocusWindow ( vd - > Window ) ;
2018-09-20 16:46:36 +00:00
# else
// 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.
( void ) viewport ;
# endif
2018-04-25 13:15:14 +00:00
}
static bool ImGui_ImplGlfw_GetWindowFocus ( ImGuiViewport * viewport )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
return glfwGetWindowAttrib ( vd - > Window , GLFW_FOCUSED ) ! = 0 ;
2018-04-25 13:15:14 +00:00
}
2018-11-23 15:18:30 +00:00
static bool ImGui_ImplGlfw_GetWindowMinimized ( ImGuiViewport * viewport )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
return glfwGetWindowAttrib ( vd - > Window , GLFW_ICONIFIED ) ! = 0 ;
2018-11-23 15:18:30 +00:00
}
2018-04-05 15:06:23 +00:00
# if GLFW_HAS_WINDOW_ALPHA
static void ImGui_ImplGlfw_SetWindowAlpha ( ImGuiViewport * viewport , float alpha )
{
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
glfwSetWindowOpacity ( vd - > Window , alpha ) ;
2018-04-05 15:06:23 +00:00
}
# endif
2018-03-19 14:20:47 +00:00
static void ImGui_ImplGlfw_RenderWindow ( ImGuiViewport * viewport , void * )
2018-02-27 22:27:41 +00:00
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2021-06-29 12:53:25 +00:00
if ( bd - > ClientApi = = GlfwClientApi_OpenGL )
2021-06-29 13:34:54 +00:00
glfwMakeContextCurrent ( vd - > Window ) ;
2018-02-27 22:27:41 +00:00
}
2018-03-19 14:20:47 +00:00
static void ImGui_ImplGlfw_SwapBuffers ( ImGuiViewport * viewport , void * )
2018-02-27 22:27:41 +00:00
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2021-06-29 12:53:25 +00:00
if ( bd - > ClientApi = = GlfwClientApi_OpenGL )
2019-03-02 02:55:55 +00:00
{
2021-06-29 13:34:54 +00:00
glfwMakeContextCurrent ( vd - > Window ) ;
glfwSwapBuffers ( vd - > Window ) ;
2019-03-02 02:55:55 +00:00
}
2018-02-27 22:27:41 +00:00
}
2018-04-24 10:40:38 +00:00
//--------------------------------------------------------------------------------------------------------
2018-03-13 22:16:15 +00:00
// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
2018-04-24 10:40:38 +00:00
//--------------------------------------------------------------------------------------------------------
2018-03-13 22:16:15 +00:00
// Avoid including <vulkan.h> so we can build without it
# if GLFW_HAS_VULKAN
# ifndef VULKAN_H_
# define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
# if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
# define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
# else
# define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
# endif
VK_DEFINE_HANDLE ( VkInstance )
VK_DEFINE_NON_DISPATCHABLE_HANDLE ( VkSurfaceKHR )
struct VkAllocationCallbacks ;
enum VkResult { VK_RESULT_MAX_ENUM = 0x7FFFFFFF } ;
# endif // VULKAN_H_
extern " C " { extern GLFWAPI VkResult glfwCreateWindowSurface ( VkInstance instance , GLFWwindow * window , const VkAllocationCallbacks * allocator , VkSurfaceKHR * surface ) ; }
static int ImGui_ImplGlfw_CreateVkSurface ( ImGuiViewport * viewport , ImU64 vk_instance , const void * vk_allocator , ImU64 * out_vk_surface )
{
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = ( ImGui_ImplGlfw_ViewportData * ) viewport - > PlatformUserData ;
2021-08-22 16:46:49 +00:00
IM_UNUSED ( bd ) ;
2021-06-29 12:53:25 +00:00
IM_ASSERT ( bd - > ClientApi = = GlfwClientApi_Vulkan ) ;
2021-06-29 13:34:54 +00:00
VkResult err = glfwCreateWindowSurface ( ( VkInstance ) vk_instance , vd - > Window , ( const VkAllocationCallbacks * ) vk_allocator , ( VkSurfaceKHR * ) out_vk_surface ) ;
2018-03-13 22:16:15 +00:00
return ( int ) err ;
}
# endif // GLFW_HAS_VULKAN
2018-02-27 22:27:41 +00:00
static void ImGui_ImplGlfw_InitPlatformInterface ( )
{
// Register platform interface (will be coupled with a renderer interface)
2021-06-29 12:53:25 +00:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2018-03-18 17:44:57 +00:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
platform_io . Platform_CreateWindow = ImGui_ImplGlfw_CreateWindow ;
platform_io . Platform_DestroyWindow = ImGui_ImplGlfw_DestroyWindow ;
platform_io . Platform_ShowWindow = ImGui_ImplGlfw_ShowWindow ;
platform_io . Platform_SetWindowPos = ImGui_ImplGlfw_SetWindowPos ;
platform_io . Platform_GetWindowPos = ImGui_ImplGlfw_GetWindowPos ;
platform_io . Platform_SetWindowSize = ImGui_ImplGlfw_SetWindowSize ;
platform_io . Platform_GetWindowSize = ImGui_ImplGlfw_GetWindowSize ;
2018-04-25 13:15:14 +00:00
platform_io . Platform_SetWindowFocus = ImGui_ImplGlfw_SetWindowFocus ;
platform_io . Platform_GetWindowFocus = ImGui_ImplGlfw_GetWindowFocus ;
2018-11-23 15:18:30 +00:00
platform_io . Platform_GetWindowMinimized = ImGui_ImplGlfw_GetWindowMinimized ;
2018-03-18 17:44:57 +00:00
platform_io . Platform_SetWindowTitle = ImGui_ImplGlfw_SetWindowTitle ;
platform_io . Platform_RenderWindow = ImGui_ImplGlfw_RenderWindow ;
platform_io . Platform_SwapBuffers = ImGui_ImplGlfw_SwapBuffers ;
2018-04-05 15:06:23 +00:00
# if GLFW_HAS_WINDOW_ALPHA
platform_io . Platform_SetWindowAlpha = ImGui_ImplGlfw_SetWindowAlpha ;
# endif
2018-03-13 22:16:15 +00:00
# if GLFW_HAS_VULKAN
2018-03-18 17:44:57 +00:00
platform_io . Platform_CreateVkSurface = ImGui_ImplGlfw_CreateVkSurface ;
2018-03-13 22:16:15 +00:00
# endif
2018-03-12 17:43:25 +00:00
2018-04-09 20:01:24 +00:00
// Register main window handle (which is owned by the main application, not by us)
2020-01-20 18:33:46 +00:00
// 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.
2018-02-27 22:27:41 +00:00
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2021-06-29 13:34:54 +00:00
ImGui_ImplGlfw_ViewportData * vd = IM_NEW ( ImGui_ImplGlfw_ViewportData ) ( ) ;
vd - > Window = bd - > Window ;
vd - > WindowOwned = false ;
main_viewport - > PlatformUserData = vd ;
2021-06-29 12:53:25 +00:00
main_viewport - > PlatformHandle = ( void * ) bd - > Window ;
2018-02-27 22:27:41 +00:00
}
static void ImGui_ImplGlfw_ShutdownPlatformInterface ( )
{
2021-10-15 15:16:26 +00:00
ImGui : : DestroyPlatformWindows ( ) ;
2018-02-27 22:27:41 +00:00
}
2021-12-30 20:42:19 +00:00
2021-12-29 11:41:34 +00:00
# if defined(__clang__)
# pragma clang diagnostic pop
# endif
