Merge branch 'master' into docking
# Conflicts:
# backends/imgui_impl_sdl3.cpp
# docs/CHANGELOG.txt
# imgui.cpp
# imgui.h
# imgui_internal.h
diff --git a/backends/imgui_impl_allegro5.cpp b/backends/imgui_impl_allegro5.cpp
index e41f021..2737aa2 100644
--- a/backends/imgui_impl_allegro5.cpp
+++ b/backends/imgui_impl_allegro5.cpp
@@ -6,7 +6,8 @@
// [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 ALLEGRO_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Clipboard support (from Allegro 5.1.12)
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
-// Issues:
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows)..
// [ ] Renderer: The renderer is suboptimal as we need to convert vertices manually.
// [ ] Platform: Missing gamepad support.
diff --git a/backends/imgui_impl_allegro5.h b/backends/imgui_impl_allegro5.h
index f1501ec..7b2e190 100644
--- a/backends/imgui_impl_allegro5.h
+++ b/backends/imgui_impl_allegro5.h
@@ -6,7 +6,8 @@
// [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 ALLEGRO_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Clipboard support (from Allegro 5.1.12)
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
-// Issues:
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows)..
// [ ] Renderer: The renderer is suboptimal as we need to unindex our buffers and convert vertices manually.
// [ ] Platform: Missing gamepad support.
diff --git a/backends/imgui_impl_android.cpp b/backends/imgui_impl_android.cpp
index b0c4639..994b0c6 100644
--- a/backends/imgui_impl_android.cpp
+++ b/backends/imgui_impl_android.cpp
@@ -8,6 +8,7 @@
// [ ] Platform: Clipboard support.
// [ ] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [ ] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. FIXME: Check if this is even possible with Android.
+// [ ] Platform: Multi-viewport support (multiple windows). Not meaningful on Android.
// Important:
// - Consider using SDL or GLFW backend on Android, which will be more full-featured than this.
// - FIXME: On-screen keyboard currently needs to be enabled by the application (see examples/ and issue #3446)
diff --git a/backends/imgui_impl_android.h b/backends/imgui_impl_android.h
index 92a044d..d7e7fb9 100644
--- a/backends/imgui_impl_android.h
+++ b/backends/imgui_impl_android.h
@@ -8,6 +8,7 @@
// [ ] Platform: Clipboard support.
// [ ] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [ ] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. FIXME: Check if this is even possible with Android.
+// [ ] Platform: Multi-viewport support (multiple windows). Not meaningful on Android.
// Important:
// - Consider using SDL or GLFW backend on Android, which will be more full-featured than this.
// - FIXME: On-screen keyboard currently needs to be enabled by the application (see examples/ and issue #3446)
diff --git a/backends/imgui_impl_dx10.cpp b/backends/imgui_impl_dx10.cpp
index 9691b49..0123aa6 100644
--- a/backends/imgui_impl_dx10.cpp
+++ b/backends/imgui_impl_dx10.cpp
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'ID3D10ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -15,6 +16,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
// 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).
// 2021-05-19: DirectX10: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
@@ -79,6 +81,10 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplDX10_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplDX10_InitPlatformInterface();
+static void ImGui_ImplDX10_ShutdownPlatformInterface();
+
// Functions
static void ImGui_ImplDX10_SetupRenderState(ImDrawData* draw_data, ID3D10Device* ctx)
{
@@ -542,6 +548,7 @@
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_dx10";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
// Get factory from device
IDXGIDevice* pDXGIDevice = nullptr;
@@ -558,6 +565,8 @@
if (pDXGIAdapter) pDXGIAdapter->Release();
bd->pd3dDevice->AddRef();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplDX10_InitPlatformInterface();
return true;
}
@@ -567,12 +576,13 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplDX10_ShutdownPlatformInterface();
ImGui_ImplDX10_InvalidateDeviceObjects();
if (bd->pFactory) { bd->pFactory->Release(); }
if (bd->pd3dDevice) { bd->pd3dDevice->Release(); }
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
IM_DELETE(bd);
}
@@ -585,6 +595,129 @@
ImGui_ImplDX10_CreateDeviceObjects();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplDX10_ViewportData
+{
+ IDXGISwapChain* SwapChain;
+ ID3D10RenderTargetView* RTView;
+
+ ImGui_ImplDX10_ViewportData() { SwapChain = nullptr; RTView = nullptr; }
+ ~ImGui_ImplDX10_ViewportData() { IM_ASSERT(SwapChain == nullptr && RTView == nullptr); }
+};
+
+static void ImGui_ImplDX10_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplDX10_Data* bd = ImGui_ImplDX10_GetBackendData();
+ ImGui_ImplDX10_ViewportData* vd = IM_NEW(ImGui_ImplDX10_ViewportData)();
+ viewport->RendererUserData = vd;
+
+ // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*).
+ // Some backends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the HWND.
+ HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle;
+ IM_ASSERT(hwnd != 0);
+
+ // Create swap chain
+ DXGI_SWAP_CHAIN_DESC sd;
+ ZeroMemory(&sd, sizeof(sd));
+ sd.BufferDesc.Width = (UINT)viewport->Size.x;
+ sd.BufferDesc.Height = (UINT)viewport->Size.y;
+ sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ sd.SampleDesc.Count = 1;
+ sd.SampleDesc.Quality = 0;
+ sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ sd.BufferCount = 1;
+ sd.OutputWindow = hwnd;
+ sd.Windowed = TRUE;
+ sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+ sd.Flags = 0;
+
+ IM_ASSERT(vd->SwapChain == nullptr && vd->RTView == nullptr);
+ bd->pFactory->CreateSwapChain(bd->pd3dDevice, &sd, &vd->SwapChain);
+
+ // Create the render target
+ if (vd->SwapChain)
+ {
+ ID3D10Texture2D* pBackBuffer;
+ vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer));
+ bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &vd->RTView);
+ pBackBuffer->Release();
+ }
+}
+
+static void ImGui_ImplDX10_DestroyWindow(ImGuiViewport* viewport)
+{
+ // The main viewport (owned by the application) will always have RendererUserData == 0 here since we didn't create the data for it.
+ if (ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData)
+ {
+ if (vd->SwapChain)
+ vd->SwapChain->Release();
+ vd->SwapChain = nullptr;
+ if (vd->RTView)
+ vd->RTView->Release();
+ vd->RTView = nullptr;
+ IM_DELETE(vd);
+ }
+ viewport->RendererUserData = nullptr;
+}
+
+static void ImGui_ImplDX10_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplDX10_Data* bd = ImGui_ImplDX10_GetBackendData();
+ ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData;
+ if (vd->RTView)
+ {
+ vd->RTView->Release();
+ vd->RTView = nullptr;
+ }
+ if (vd->SwapChain)
+ {
+ ID3D10Texture2D* pBackBuffer = nullptr;
+ vd->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0);
+ vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer));
+ if (pBackBuffer == nullptr) { fprintf(stderr, "ImGui_ImplDX10_SetWindowSize() failed creating buffers.\n"); return; }
+ bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &vd->RTView);
+ pBackBuffer->Release();
+ }
+}
+
+static void ImGui_ImplDX10_RenderViewport(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX10_Data* bd = ImGui_ImplDX10_GetBackendData();
+ ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData;
+ ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+ bd->pd3dDevice->OMSetRenderTargets(1, &vd->RTView, nullptr);
+ if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+ bd->pd3dDevice->ClearRenderTargetView(vd->RTView, (float*)&clear_color);
+ ImGui_ImplDX10_RenderDrawData(viewport->DrawData);
+}
+
+static void ImGui_ImplDX10_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX10_ViewportData* vd = (ImGui_ImplDX10_ViewportData*)viewport->RendererUserData;
+ vd->SwapChain->Present(0, 0); // Present without vsync
+}
+
+void ImGui_ImplDX10_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_CreateWindow = ImGui_ImplDX10_CreateWindow;
+ platform_io.Renderer_DestroyWindow = ImGui_ImplDX10_DestroyWindow;
+ platform_io.Renderer_SetWindowSize = ImGui_ImplDX10_SetWindowSize;
+ platform_io.Renderer_RenderWindow = ImGui_ImplDX10_RenderViewport;
+ platform_io.Renderer_SwapBuffers = ImGui_ImplDX10_SwapBuffers;
+}
+
+void ImGui_ImplDX10_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#endif // #ifndef IMGUI_DISABLE
diff --git a/backends/imgui_impl_dx10.h b/backends/imgui_impl_dx10.h
index 9575973..f6286de 100644
--- a/backends/imgui_impl_dx10.h
+++ b/backends/imgui_impl_dx10.h
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'ID3D10ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_dx11.cpp b/backends/imgui_impl_dx11.cpp
index 167bda6..3d7ec7e 100644
--- a/backends/imgui_impl_dx11.cpp
+++ b/backends/imgui_impl_dx11.cpp
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -15,6 +16,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
// 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).
// 2021-05-19: DirectX11: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
@@ -80,6 +82,10 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplDX11_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplDX11_InitPlatformInterface();
+static void ImGui_ImplDX11_ShutdownPlatformInterface();
+
// Functions
static void ImGui_ImplDX11_SetupRenderState(ImDrawData* draw_data, ID3D11DeviceContext* ctx)
{
@@ -554,6 +560,7 @@
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_dx11";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
// Get factory from device
IDXGIDevice* pDXGIDevice = nullptr;
@@ -573,6 +580,9 @@
bd->pd3dDevice->AddRef();
bd->pd3dDeviceContext->AddRef();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplDX11_InitPlatformInterface();
+
return true;
}
@@ -582,13 +592,14 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplDX11_ShutdownPlatformInterface();
ImGui_ImplDX11_InvalidateDeviceObjects();
if (bd->pFactory) { bd->pFactory->Release(); }
if (bd->pd3dDevice) { bd->pd3dDevice->Release(); }
if (bd->pd3dDeviceContext) { bd->pd3dDeviceContext->Release(); }
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
IM_DELETE(bd);
}
@@ -601,6 +612,129 @@
ImGui_ImplDX11_CreateDeviceObjects();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplDX11_ViewportData
+{
+ IDXGISwapChain* SwapChain;
+ ID3D11RenderTargetView* RTView;
+
+ ImGui_ImplDX11_ViewportData() { SwapChain = nullptr; RTView = nullptr; }
+ ~ImGui_ImplDX11_ViewportData() { IM_ASSERT(SwapChain == nullptr && RTView == nullptr); }
+};
+
+static void ImGui_ImplDX11_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+ ImGui_ImplDX11_ViewportData* vd = IM_NEW(ImGui_ImplDX11_ViewportData)();
+ viewport->RendererUserData = vd;
+
+ // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*).
+ // Some backends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the HWND.
+ HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle;
+ IM_ASSERT(hwnd != 0);
+
+ // Create swap chain
+ DXGI_SWAP_CHAIN_DESC sd;
+ ZeroMemory(&sd, sizeof(sd));
+ sd.BufferDesc.Width = (UINT)viewport->Size.x;
+ sd.BufferDesc.Height = (UINT)viewport->Size.y;
+ sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ sd.SampleDesc.Count = 1;
+ sd.SampleDesc.Quality = 0;
+ sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ sd.BufferCount = 1;
+ sd.OutputWindow = hwnd;
+ sd.Windowed = TRUE;
+ sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+ sd.Flags = 0;
+
+ IM_ASSERT(vd->SwapChain == nullptr && vd->RTView == nullptr);
+ bd->pFactory->CreateSwapChain(bd->pd3dDevice, &sd, &vd->SwapChain);
+
+ // Create the render target
+ if (vd->SwapChain)
+ {
+ ID3D11Texture2D* pBackBuffer;
+ vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer));
+ bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &vd->RTView);
+ pBackBuffer->Release();
+ }
+}
+
+static void ImGui_ImplDX11_DestroyWindow(ImGuiViewport* viewport)
+{
+ // The main viewport (owned by the application) will always have RendererUserData == nullptr since we didn't create the data for it.
+ if (ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData)
+ {
+ if (vd->SwapChain)
+ vd->SwapChain->Release();
+ vd->SwapChain = nullptr;
+ if (vd->RTView)
+ vd->RTView->Release();
+ vd->RTView = nullptr;
+ IM_DELETE(vd);
+ }
+ viewport->RendererUserData = nullptr;
+}
+
+static void ImGui_ImplDX11_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+ ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData;
+ if (vd->RTView)
+ {
+ vd->RTView->Release();
+ vd->RTView = nullptr;
+ }
+ if (vd->SwapChain)
+ {
+ ID3D11Texture2D* pBackBuffer = nullptr;
+ vd->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0);
+ vd->SwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer));
+ if (pBackBuffer == nullptr) { fprintf(stderr, "ImGui_ImplDX11_SetWindowSize() failed creating buffers.\n"); return; }
+ bd->pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &vd->RTView);
+ pBackBuffer->Release();
+ }
+}
+
+static void ImGui_ImplDX11_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
+ ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData;
+ ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+ bd->pd3dDeviceContext->OMSetRenderTargets(1, &vd->RTView, nullptr);
+ if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+ bd->pd3dDeviceContext->ClearRenderTargetView(vd->RTView, (float*)&clear_color);
+ ImGui_ImplDX11_RenderDrawData(viewport->DrawData);
+}
+
+static void ImGui_ImplDX11_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX11_ViewportData* vd = (ImGui_ImplDX11_ViewportData*)viewport->RendererUserData;
+ vd->SwapChain->Present(0, 0); // Present without vsync
+}
+
+static void ImGui_ImplDX11_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_CreateWindow = ImGui_ImplDX11_CreateWindow;
+ platform_io.Renderer_DestroyWindow = ImGui_ImplDX11_DestroyWindow;
+ platform_io.Renderer_SetWindowSize = ImGui_ImplDX11_SetWindowSize;
+ platform_io.Renderer_RenderWindow = ImGui_ImplDX11_RenderWindow;
+ platform_io.Renderer_SwapBuffers = ImGui_ImplDX11_SwapBuffers;
+}
+
+static void ImGui_ImplDX11_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#endif // #ifndef IMGUI_DISABLE
diff --git a/backends/imgui_impl_dx11.h b/backends/imgui_impl_dx11.h
index cde64ee..030b3e3 100644
--- a/backends/imgui_impl_dx11.h
+++ b/backends/imgui_impl_dx11.h
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_dx12.cpp b/backends/imgui_impl_dx12.cpp
index 32f1622..cde8981 100644
--- a/backends/imgui_impl_dx12.cpp
+++ b/backends/imgui_impl_dx12.cpp
@@ -4,6 +4,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'D3D12_GPU_DESCRIPTOR_HANDLE' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+// FIXME: The transition from removing a viewport and moving the window in an existing hosted viewport tends to flicker.
// Important: to compile on 32-bit systems, this backend requires code to be compiled with '#define ImTextureID ImU64'.
// This is because we need ImTextureID to carry a 64-bit value and by default ImTextureID is defined as void*.
@@ -23,6 +25,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
// 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).
// 2021-05-19: DirectX12: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
@@ -54,7 +57,6 @@
#endif
// DirectX data
-struct ImGui_ImplDX12_RenderBuffers;
struct ImGui_ImplDX12_Data
{
ID3D12Device* pd3dDevice;
@@ -67,10 +69,7 @@
ID3D12DescriptorHeap* pd3dSrvDescHeap;
UINT numFramesInFlight;
- ImGui_ImplDX12_RenderBuffers* pFrameResources;
- UINT frameIndex;
-
- ImGui_ImplDX12_Data() { memset((void*)this, 0, sizeof(*this)); frameIndex = UINT_MAX; }
+ ImGui_ImplDX12_Data() { memset((void*)this, 0, sizeof(*this)); }
};
// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
@@ -89,11 +88,88 @@
int VertexBufferSize;
};
+// Buffers used for secondary viewports created by the multi-viewports systems
+struct ImGui_ImplDX12_FrameContext
+{
+ ID3D12CommandAllocator* CommandAllocator;
+ ID3D12Resource* RenderTarget;
+ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetCpuDescriptors;
+};
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+// Main viewport created by application will only use the Resources field.
+// Secondary viewports created by this backend will use all the fields (including Window fields),
+struct ImGui_ImplDX12_ViewportData
+{
+ // Window
+ ID3D12CommandQueue* CommandQueue;
+ ID3D12GraphicsCommandList* CommandList;
+ ID3D12DescriptorHeap* RtvDescHeap;
+ IDXGISwapChain3* SwapChain;
+ ID3D12Fence* Fence;
+ UINT64 FenceSignaledValue;
+ HANDLE FenceEvent;
+ UINT NumFramesInFlight;
+ ImGui_ImplDX12_FrameContext* FrameCtx;
+
+ // Render buffers
+ UINT FrameIndex;
+ ImGui_ImplDX12_RenderBuffers* FrameRenderBuffers;
+
+ ImGui_ImplDX12_ViewportData(UINT num_frames_in_flight)
+ {
+ CommandQueue = nullptr;
+ CommandList = nullptr;
+ RtvDescHeap = nullptr;
+ SwapChain = nullptr;
+ Fence = nullptr;
+ FenceSignaledValue = 0;
+ FenceEvent = nullptr;
+ NumFramesInFlight = num_frames_in_flight;
+ FrameCtx = new ImGui_ImplDX12_FrameContext[NumFramesInFlight];
+ FrameIndex = UINT_MAX;
+ FrameRenderBuffers = new ImGui_ImplDX12_RenderBuffers[NumFramesInFlight];
+
+ for (UINT i = 0; i < NumFramesInFlight; ++i)
+ {
+ FrameCtx[i].CommandAllocator = nullptr;
+ FrameCtx[i].RenderTarget = nullptr;
+
+ // Create buffers with a default size (they will later be grown as needed)
+ FrameRenderBuffers[i].IndexBuffer = nullptr;
+ FrameRenderBuffers[i].VertexBuffer = nullptr;
+ FrameRenderBuffers[i].VertexBufferSize = 5000;
+ FrameRenderBuffers[i].IndexBufferSize = 10000;
+ }
+ }
+ ~ImGui_ImplDX12_ViewportData()
+ {
+ IM_ASSERT(CommandQueue == nullptr && CommandList == nullptr);
+ IM_ASSERT(RtvDescHeap == nullptr);
+ IM_ASSERT(SwapChain == nullptr);
+ IM_ASSERT(Fence == nullptr);
+ IM_ASSERT(FenceEvent == nullptr);
+
+ for (UINT i = 0; i < NumFramesInFlight; ++i)
+ {
+ IM_ASSERT(FrameCtx[i].CommandAllocator == nullptr && FrameCtx[i].RenderTarget == nullptr);
+ IM_ASSERT(FrameRenderBuffers[i].IndexBuffer == nullptr && FrameRenderBuffers[i].VertexBuffer == nullptr);
+ }
+
+ delete[] FrameCtx; FrameCtx = nullptr;
+ delete[] FrameRenderBuffers; FrameRenderBuffers = nullptr;
+ }
+};
+
struct VERTEX_CONSTANT_BUFFER_DX12
{
float mvp[4][4];
};
+// Forward Declarations
+static void ImGui_ImplDX12_InitPlatformInterface();
+static void ImGui_ImplDX12_ShutdownPlatformInterface();
+
// Functions
static void ImGui_ImplDX12_SetupRenderState(ImDrawData* draw_data, ID3D12GraphicsCommandList* ctx, ImGui_ImplDX12_RenderBuffers* fr)
{
@@ -167,11 +243,10 @@
if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f)
return;
- // FIXME: I'm assuming that this only gets called once per frame!
- // If not, we can't just re-allocate the IB or VB, we'll have to do a proper allocator.
ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData();
- bd->frameIndex = bd->frameIndex + 1;
- ImGui_ImplDX12_RenderBuffers* fr = &bd->pFrameResources[bd->frameIndex % bd->numFramesInFlight];
+ ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)draw_data->OwnerViewport->RendererUserData;
+ vd->FrameIndex++;
+ ImGui_ImplDX12_RenderBuffers* fr = &vd->FrameRenderBuffers[vd->FrameIndex % bd->numFramesInFlight];
// Create and grow vertex/index buffers if needed
if (fr->VertexBuffer == nullptr || fr->VertexBufferSize < draw_data->TotalVtxCount)
@@ -678,6 +753,13 @@
return true;
}
+static void ImGui_ImplDX12_DestroyRenderBuffers(ImGui_ImplDX12_RenderBuffers* render_buffers)
+{
+ SafeRelease(render_buffers->IndexBuffer);
+ SafeRelease(render_buffers->VertexBuffer);
+ render_buffers->IndexBufferSize = render_buffers->VertexBufferSize = 0;
+}
+
void ImGui_ImplDX12_InvalidateDeviceObjects()
{
ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData();
@@ -689,13 +771,6 @@
SafeRelease(bd->pPipelineState);
SafeRelease(bd->pFontTextureResource);
io.Fonts->SetTexID(0); // We copied bd->pFontTextureView to io.Fonts->TexID so let's clear that as well.
-
- for (UINT i = 0; i < bd->numFramesInFlight; i++)
- {
- ImGui_ImplDX12_RenderBuffers* fr = &bd->pFrameResources[i];
- SafeRelease(fr->IndexBuffer);
- SafeRelease(fr->VertexBuffer);
- }
}
bool ImGui_ImplDX12_Init(ID3D12Device* device, int num_frames_in_flight, DXGI_FORMAT rtv_format, ID3D12DescriptorHeap* cbv_srv_heap,
@@ -710,25 +785,21 @@
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_dx12";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplDX12_InitPlatformInterface();
bd->pd3dDevice = device;
bd->RTVFormat = rtv_format;
bd->hFontSrvCpuDescHandle = font_srv_cpu_desc_handle;
bd->hFontSrvGpuDescHandle = font_srv_gpu_desc_handle;
- bd->pFrameResources = new ImGui_ImplDX12_RenderBuffers[num_frames_in_flight];
bd->numFramesInFlight = num_frames_in_flight;
bd->pd3dSrvDescHeap = cbv_srv_heap;
- bd->frameIndex = UINT_MAX;
- // Create buffers with a default size (they will later be grown as needed)
- for (int i = 0; i < num_frames_in_flight; i++)
- {
- ImGui_ImplDX12_RenderBuffers* fr = &bd->pFrameResources[i];
- fr->IndexBuffer = nullptr;
- fr->VertexBuffer = nullptr;
- fr->IndexBufferSize = 10000;
- fr->VertexBufferSize = 5000;
- }
+ // Create a dummy ImGui_ImplDX12_ViewportData holder for the main viewport,
+ // Since this is created and managed by the application, we will only use the ->Resources[] fields.
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ main_viewport->RendererUserData = IM_NEW(ImGui_ImplDX12_ViewportData)(bd->numFramesInFlight);
return true;
}
@@ -739,12 +810,24 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ // Manually delete main viewport render resources in-case we haven't initialized for viewports
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ if (ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)main_viewport->RendererUserData)
+ {
+ // We could just call ImGui_ImplDX12_DestroyWindow(main_viewport) as a convenience but that would be misleading since we only use data->Resources[]
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ ImGui_ImplDX12_DestroyRenderBuffers(&vd->FrameRenderBuffers[i]);
+ IM_DELETE(vd);
+ main_viewport->RendererUserData = nullptr;
+ }
+
// Clean up windows and device objects
+ ImGui_ImplDX12_ShutdownPlatformInterface();
ImGui_ImplDX12_InvalidateDeviceObjects();
- delete[] bd->pFrameResources;
+
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
IM_DELETE(bd);
}
@@ -757,6 +840,246 @@
ImGui_ImplDX12_CreateDeviceObjects();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+static void ImGui_ImplDX12_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData();
+ ImGui_ImplDX12_ViewportData* vd = IM_NEW(ImGui_ImplDX12_ViewportData)(bd->numFramesInFlight);
+ viewport->RendererUserData = vd;
+
+ // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*).
+ // Some backends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the HWND.
+ HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle;
+ IM_ASSERT(hwnd != 0);
+
+ vd->FrameIndex = UINT_MAX;
+
+ // Create command queue.
+ D3D12_COMMAND_QUEUE_DESC queue_desc = {};
+ queue_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+ queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+
+ HRESULT res = S_OK;
+ res = bd->pd3dDevice->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&vd->CommandQueue));
+ IM_ASSERT(res == S_OK);
+
+ // Create command allocator.
+ for (UINT i = 0; i < bd->numFramesInFlight; ++i)
+ {
+ res = bd->pd3dDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&vd->FrameCtx[i].CommandAllocator));
+ IM_ASSERT(res == S_OK);
+ }
+
+ // Create command list.
+ res = bd->pd3dDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, vd->FrameCtx[0].CommandAllocator, nullptr, IID_PPV_ARGS(&vd->CommandList));
+ IM_ASSERT(res == S_OK);
+ vd->CommandList->Close();
+
+ // Create fence.
+ res = bd->pd3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&vd->Fence));
+ IM_ASSERT(res == S_OK);
+
+ vd->FenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+ IM_ASSERT(vd->FenceEvent != nullptr);
+
+ // Create swap chain
+ // FIXME-VIEWPORT: May want to copy/inherit swap chain settings from the user/application.
+ DXGI_SWAP_CHAIN_DESC1 sd1;
+ ZeroMemory(&sd1, sizeof(sd1));
+ sd1.BufferCount = bd->numFramesInFlight;
+ sd1.Width = (UINT)viewport->Size.x;
+ sd1.Height = (UINT)viewport->Size.y;
+ sd1.Format = bd->RTVFormat;
+ sd1.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ sd1.SampleDesc.Count = 1;
+ sd1.SampleDesc.Quality = 0;
+ sd1.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
+ sd1.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
+ sd1.Scaling = DXGI_SCALING_NONE;
+ sd1.Stereo = FALSE;
+
+ IDXGIFactory4* dxgi_factory = nullptr;
+ res = ::CreateDXGIFactory1(IID_PPV_ARGS(&dxgi_factory));
+ IM_ASSERT(res == S_OK);
+
+ IDXGISwapChain1* swap_chain = nullptr;
+ res = dxgi_factory->CreateSwapChainForHwnd(vd->CommandQueue, hwnd, &sd1, nullptr, nullptr, &swap_chain);
+ IM_ASSERT(res == S_OK);
+
+ dxgi_factory->Release();
+
+ // Or swapChain.As(&mSwapChain)
+ IM_ASSERT(vd->SwapChain == nullptr);
+ swap_chain->QueryInterface(IID_PPV_ARGS(&vd->SwapChain));
+ swap_chain->Release();
+
+ // Create the render targets
+ if (vd->SwapChain)
+ {
+ D3D12_DESCRIPTOR_HEAP_DESC desc = {};
+ desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+ desc.NumDescriptors = bd->numFramesInFlight;
+ desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+ desc.NodeMask = 1;
+
+ HRESULT hr = bd->pd3dDevice->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&vd->RtvDescHeap));
+ IM_ASSERT(hr == S_OK);
+
+ SIZE_T rtv_descriptor_size = bd->pd3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+ D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = vd->RtvDescHeap->GetCPUDescriptorHandleForHeapStart();
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ {
+ vd->FrameCtx[i].RenderTargetCpuDescriptors = rtv_handle;
+ rtv_handle.ptr += rtv_descriptor_size;
+ }
+
+ ID3D12Resource* back_buffer;
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ {
+ IM_ASSERT(vd->FrameCtx[i].RenderTarget == nullptr);
+ vd->SwapChain->GetBuffer(i, IID_PPV_ARGS(&back_buffer));
+ bd->pd3dDevice->CreateRenderTargetView(back_buffer, nullptr, vd->FrameCtx[i].RenderTargetCpuDescriptors);
+ vd->FrameCtx[i].RenderTarget = back_buffer;
+ }
+ }
+
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ ImGui_ImplDX12_DestroyRenderBuffers(&vd->FrameRenderBuffers[i]);
+}
+
+static void ImGui_WaitForPendingOperations(ImGui_ImplDX12_ViewportData* vd)
+{
+ HRESULT hr = S_FALSE;
+ if (vd && vd->CommandQueue && vd->Fence && vd->FenceEvent)
+ {
+ hr = vd->CommandQueue->Signal(vd->Fence, ++vd->FenceSignaledValue);
+ IM_ASSERT(hr == S_OK);
+ ::WaitForSingleObject(vd->FenceEvent, 0); // Reset any forgotten waits
+ hr = vd->Fence->SetEventOnCompletion(vd->FenceSignaledValue, vd->FenceEvent);
+ IM_ASSERT(hr == S_OK);
+ ::WaitForSingleObject(vd->FenceEvent, INFINITE);
+ }
+}
+
+static void ImGui_ImplDX12_DestroyWindow(ImGuiViewport* viewport)
+{
+ // The main viewport (owned by the application) will always have RendererUserData == 0 since we didn't create the data for it.
+ ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData();
+ if (ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData)
+ {
+ ImGui_WaitForPendingOperations(vd);
+
+ SafeRelease(vd->CommandQueue);
+ SafeRelease(vd->CommandList);
+ SafeRelease(vd->SwapChain);
+ SafeRelease(vd->RtvDescHeap);
+ SafeRelease(vd->Fence);
+ ::CloseHandle(vd->FenceEvent);
+ vd->FenceEvent = nullptr;
+
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ {
+ SafeRelease(vd->FrameCtx[i].RenderTarget);
+ SafeRelease(vd->FrameCtx[i].CommandAllocator);
+ ImGui_ImplDX12_DestroyRenderBuffers(&vd->FrameRenderBuffers[i]);
+ }
+ IM_DELETE(vd);
+ }
+ viewport->RendererUserData = nullptr;
+}
+
+static void ImGui_ImplDX12_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData();
+ ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData;
+
+ ImGui_WaitForPendingOperations(vd);
+
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ SafeRelease(vd->FrameCtx[i].RenderTarget);
+
+ if (vd->SwapChain)
+ {
+ ID3D12Resource* back_buffer = nullptr;
+ vd->SwapChain->ResizeBuffers(0, (UINT)size.x, (UINT)size.y, DXGI_FORMAT_UNKNOWN, 0);
+ for (UINT i = 0; i < bd->numFramesInFlight; i++)
+ {
+ vd->SwapChain->GetBuffer(i, IID_PPV_ARGS(&back_buffer));
+ bd->pd3dDevice->CreateRenderTargetView(back_buffer, nullptr, vd->FrameCtx[i].RenderTargetCpuDescriptors);
+ vd->FrameCtx[i].RenderTarget = back_buffer;
+ }
+ }
+}
+
+static void ImGui_ImplDX12_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX12_Data* bd = ImGui_ImplDX12_GetBackendData();
+ ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData;
+
+ ImGui_ImplDX12_FrameContext* frame_context = &vd->FrameCtx[vd->FrameIndex % bd->numFramesInFlight];
+ UINT back_buffer_idx = vd->SwapChain->GetCurrentBackBufferIndex();
+
+ const ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+ D3D12_RESOURCE_BARRIER barrier = {};
+ barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+ barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
+ barrier.Transition.pResource = vd->FrameCtx[back_buffer_idx].RenderTarget;
+ barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
+ barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
+ barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
+
+ // Draw
+ ID3D12GraphicsCommandList* cmd_list = vd->CommandList;
+
+ frame_context->CommandAllocator->Reset();
+ cmd_list->Reset(frame_context->CommandAllocator, nullptr);
+ cmd_list->ResourceBarrier(1, &barrier);
+ cmd_list->OMSetRenderTargets(1, &vd->FrameCtx[back_buffer_idx].RenderTargetCpuDescriptors, FALSE, nullptr);
+ if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+ cmd_list->ClearRenderTargetView(vd->FrameCtx[back_buffer_idx].RenderTargetCpuDescriptors, (float*)&clear_color, 0, nullptr);
+ cmd_list->SetDescriptorHeaps(1, &bd->pd3dSrvDescHeap);
+
+ ImGui_ImplDX12_RenderDrawData(viewport->DrawData, cmd_list);
+
+ barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
+ barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
+ cmd_list->ResourceBarrier(1, &barrier);
+ cmd_list->Close();
+
+ vd->CommandQueue->Wait(vd->Fence, vd->FenceSignaledValue);
+ vd->CommandQueue->ExecuteCommandLists(1, (ID3D12CommandList* const*)&cmd_list);
+ vd->CommandQueue->Signal(vd->Fence, ++vd->FenceSignaledValue);
+}
+
+static void ImGui_ImplDX12_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX12_ViewportData* vd = (ImGui_ImplDX12_ViewportData*)viewport->RendererUserData;
+
+ vd->SwapChain->Present(0, 0);
+ while (vd->Fence->GetCompletedValue() < vd->FenceSignaledValue)
+ ::SwitchToThread();
+}
+
+void ImGui_ImplDX12_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_CreateWindow = ImGui_ImplDX12_CreateWindow;
+ platform_io.Renderer_DestroyWindow = ImGui_ImplDX12_DestroyWindow;
+ platform_io.Renderer_SetWindowSize = ImGui_ImplDX12_SetWindowSize;
+ platform_io.Renderer_RenderWindow = ImGui_ImplDX12_RenderWindow;
+ platform_io.Renderer_SwapBuffers = ImGui_ImplDX12_SwapBuffers;
+}
+
+void ImGui_ImplDX12_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#endif // #ifndef IMGUI_DISABLE
diff --git a/backends/imgui_impl_dx12.h b/backends/imgui_impl_dx12.h
index e1fd07d..ad1cad1 100644
--- a/backends/imgui_impl_dx12.h
+++ b/backends/imgui_impl_dx12.h
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'D3D12_GPU_DESCRIPTOR_HANDLE' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// Important: to compile on 32-bit systems, this backend requires code to be compiled with '#define ImTextureID ImU64'.
// See imgui_impl_dx12.cpp file for details.
diff --git a/backends/imgui_impl_dx9.cpp b/backends/imgui_impl_dx9.cpp
index 3eff9ab..59475d2 100644
--- a/backends/imgui_impl_dx9.cpp
+++ b/backends/imgui_impl_dx9.cpp
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -15,6 +16,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-02-12: DirectX9: Using RGBA format when supported by the driver to avoid CPU side conversion. (#6575)
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
// 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).
@@ -76,6 +78,12 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplDX9_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplDX9_InitPlatformInterface();
+static void ImGui_ImplDX9_ShutdownPlatformInterface();
+static void ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows();
+static void ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows();
+
// Functions
static void ImGui_ImplDX9_SetupRenderState(ImDrawData* draw_data)
{
@@ -272,6 +280,11 @@
global_vtx_offset += cmd_list->VtxBuffer.Size;
}
+ // When using multi-viewports, it appears that there's an odd logic in DirectX9 which prevent subsequent windows
+ // from rendering until the first window submits at least one draw call, even once. That's our workaround. (see #2560)
+ if (global_vtx_offset == 0)
+ bd->pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 0, 0, 0);
+
// Restore the DX9 transform
bd->pd3dDevice->SetTransform(D3DTS_WORLD, &last_world);
bd->pd3dDevice->SetTransform(D3DTS_VIEW, &last_view);
@@ -293,10 +306,14 @@
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_dx9";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
bd->pd3dDevice = device;
bd->pd3dDevice->AddRef();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplDX9_InitPlatformInterface();
+
return true;
}
@@ -306,11 +323,12 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplDX9_ShutdownPlatformInterface();
ImGui_ImplDX9_InvalidateDeviceObjects();
if (bd->pd3dDevice) { bd->pd3dDevice->Release(); }
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
IM_DELETE(bd);
}
@@ -384,6 +402,7 @@
return false;
if (!ImGui_ImplDX9_CreateFontsTexture())
return false;
+ ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows();
return true;
}
@@ -395,6 +414,7 @@
if (bd->pVB) { bd->pVB->Release(); bd->pVB = nullptr; }
if (bd->pIB) { bd->pIB->Release(); bd->pIB = nullptr; }
if (bd->FontTexture) { bd->FontTexture->Release(); bd->FontTexture = nullptr; ImGui::GetIO().Fonts->SetTexID(0); } // We copied bd->pFontTextureView to io.Fonts->TexID so let's clear that as well.
+ ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows();
}
void ImGui_ImplDX9_NewFrame()
@@ -406,6 +426,148 @@
ImGui_ImplDX9_CreateDeviceObjects();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplDX9_ViewportData
+{
+ IDirect3DSwapChain9* SwapChain;
+ D3DPRESENT_PARAMETERS d3dpp;
+
+ ImGui_ImplDX9_ViewportData() { SwapChain = nullptr; ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS)); }
+ ~ImGui_ImplDX9_ViewportData() { IM_ASSERT(SwapChain == nullptr); }
+};
+
+static void ImGui_ImplDX9_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+ ImGui_ImplDX9_ViewportData* vd = IM_NEW(ImGui_ImplDX9_ViewportData)();
+ viewport->RendererUserData = vd;
+
+ // PlatformHandleRaw should always be a HWND, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*).
+ // Some backends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the HWND.
+ HWND hwnd = viewport->PlatformHandleRaw ? (HWND)viewport->PlatformHandleRaw : (HWND)viewport->PlatformHandle;
+ IM_ASSERT(hwnd != 0);
+
+ ZeroMemory(&vd->d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+ vd->d3dpp.Windowed = TRUE;
+ vd->d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+ vd->d3dpp.BackBufferWidth = (UINT)viewport->Size.x;
+ vd->d3dpp.BackBufferHeight = (UINT)viewport->Size.y;
+ vd->d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
+ vd->d3dpp.hDeviceWindow = hwnd;
+ vd->d3dpp.EnableAutoDepthStencil = FALSE;
+ vd->d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
+ vd->d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // Present without vsync
+
+ HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&vd->d3dpp, &vd->SwapChain); IM_UNUSED(hr);
+ IM_ASSERT(hr == D3D_OK);
+ IM_ASSERT(vd->SwapChain != nullptr);
+}
+
+static void ImGui_ImplDX9_DestroyWindow(ImGuiViewport* viewport)
+{
+ // The main viewport (owned by the application) will always have RendererUserData == 0 since we didn't create the data for it.
+ if (ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData)
+ {
+ if (vd->SwapChain)
+ vd->SwapChain->Release();
+ vd->SwapChain = nullptr;
+ ZeroMemory(&vd->d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+ IM_DELETE(vd);
+ }
+ viewport->RendererUserData = nullptr;
+}
+
+static void ImGui_ImplDX9_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+ ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData;
+ if (vd->SwapChain)
+ {
+ vd->SwapChain->Release();
+ vd->SwapChain = nullptr;
+ vd->d3dpp.BackBufferWidth = (UINT)size.x;
+ vd->d3dpp.BackBufferHeight = (UINT)size.y;
+ HRESULT hr = bd->pd3dDevice->CreateAdditionalSwapChain(&vd->d3dpp, &vd->SwapChain); IM_UNUSED(hr);
+ IM_ASSERT(hr == D3D_OK);
+ }
+}
+
+static void ImGui_ImplDX9_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX9_Data* bd = ImGui_ImplDX9_GetBackendData();
+ ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData;
+ ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+
+ LPDIRECT3DSURFACE9 render_target = nullptr;
+ LPDIRECT3DSURFACE9 last_render_target = nullptr;
+ LPDIRECT3DSURFACE9 last_depth_stencil = nullptr;
+ vd->SwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &render_target);
+ bd->pd3dDevice->GetRenderTarget(0, &last_render_target);
+ bd->pd3dDevice->GetDepthStencilSurface(&last_depth_stencil);
+ bd->pd3dDevice->SetRenderTarget(0, render_target);
+ bd->pd3dDevice->SetDepthStencilSurface(nullptr);
+
+ if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+ {
+ D3DCOLOR clear_col_dx = D3DCOLOR_RGBA((int)(clear_color.x*255.0f), (int)(clear_color.y*255.0f), (int)(clear_color.z*255.0f), (int)(clear_color.w*255.0f));
+ bd->pd3dDevice->Clear(0, nullptr, D3DCLEAR_TARGET, clear_col_dx, 1.0f, 0);
+ }
+
+ ImGui_ImplDX9_RenderDrawData(viewport->DrawData);
+
+ // Restore render target
+ bd->pd3dDevice->SetRenderTarget(0, last_render_target);
+ bd->pd3dDevice->SetDepthStencilSurface(last_depth_stencil);
+ render_target->Release();
+ last_render_target->Release();
+ if (last_depth_stencil) last_depth_stencil->Release();
+}
+
+static void ImGui_ImplDX9_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplDX9_ViewportData* vd = (ImGui_ImplDX9_ViewportData*)viewport->RendererUserData;
+ HRESULT hr = vd->SwapChain->Present(nullptr, nullptr, vd->d3dpp.hDeviceWindow, nullptr, 0);
+ // Let main application handle D3DERR_DEVICELOST by resetting the device.
+ IM_ASSERT(SUCCEEDED(hr) || hr == D3DERR_DEVICELOST);
+}
+
+static void ImGui_ImplDX9_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_CreateWindow = ImGui_ImplDX9_CreateWindow;
+ platform_io.Renderer_DestroyWindow = ImGui_ImplDX9_DestroyWindow;
+ platform_io.Renderer_SetWindowSize = ImGui_ImplDX9_SetWindowSize;
+ platform_io.Renderer_RenderWindow = ImGui_ImplDX9_RenderWindow;
+ platform_io.Renderer_SwapBuffers = ImGui_ImplDX9_SwapBuffers;
+}
+
+static void ImGui_ImplDX9_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
+static void ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int i = 1; i < platform_io.Viewports.Size; i++)
+ if (!platform_io.Viewports[i]->RendererUserData)
+ ImGui_ImplDX9_CreateWindow(platform_io.Viewports[i]);
+}
+
+static void ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int i = 1; i < platform_io.Viewports.Size; i++)
+ if (platform_io.Viewports[i]->RendererUserData)
+ ImGui_ImplDX9_DestroyWindow(platform_io.Viewports[i]);
+}
+
//-----------------------------------------------------------------------------
#endif // #ifndef IMGUI_DISABLE
diff --git a/backends/imgui_impl_dx9.h b/backends/imgui_impl_dx9.h
index df6a0a0..f65bfb1 100644
--- a/backends/imgui_impl_dx9.h
+++ b/backends/imgui_impl_dx9.h
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_glfw.cpp b/backends/imgui_impl_glfw.cpp
index 06b5142..67ccde7 100644
--- a/backends/imgui_impl_glfw.cpp
+++ b/backends/imgui_impl_glfw.cpp
@@ -9,6 +9,9 @@
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
+// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+// Issues:
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// 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,6 +23,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-08-22: moved some OS/backend related function pointers from ImGuiIO to ImGuiPlatformIO:
// - io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn
// - io.SetClipboardTextFn -> platform_io.Platform_SetClipboardTextFn
@@ -36,6 +40,7 @@
// 2023-03-16: Inputs: Fixed key modifiers handling on secondary viewports (docking branch). Broken on 2023/01/04. (#6248, #6034)
// 2023-03-14: Emscripten: Avoid using glfwGetError() and glfwGetGamepadState() which are not correctly implemented in Emscripten emulation. (#6240)
// 2023-02-03: Emscripten: Registering custom low-level mouse wheel handler to get more accurate scrolling impulses on Emscripten. (#4019, #6096)
+// 2023-01-18: Handle unsupported glfwGetVideoMode() call on e.g. Emscripten.
// 2023-01-04: Inputs: Fixed mods state on Linux when using Alt-GR text input (e.g. German keyboard layout), could lead to broken text input. Revert a 2022/01/17 change were we resumed using mods provided by GLFW, turns out they were faulty.
// 2022-11-22: Perform a dummy glfwGetError() read to cancel missing names with glfwGetKeyName(). (#5908)
// 2022-10-18: Perform a dummy glfwGetError() read to cancel missing mouse cursors errors. Using GLFW_VERSION_COMBINED directly. (#5785)
@@ -120,11 +125,29 @@
// We gather version tests as define in order to easily see which features are version-dependent.
#define GLFW_VERSION_COMBINED (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 + GLFW_VERSION_REVISION)
+#define GLFW_HAS_WINDOW_TOPMOST (GLFW_VERSION_COMBINED >= 3200) // 3.2+ GLFW_FLOATING
+#define GLFW_HAS_WINDOW_HOVERED (GLFW_VERSION_COMBINED >= 3300) // 3.3+ GLFW_HOVERED
+#define GLFW_HAS_WINDOW_ALPHA (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwSetWindowOpacity
+#define GLFW_HAS_PER_MONITOR_DPI (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetMonitorContentScale
+#if defined(__EMSCRIPTEN__) || defined(__SWITCH__) // no Vulkan support in GLFW for Emscripten or homebrew Nintendo Switch
+#define GLFW_HAS_VULKAN (0)
+#else
+#define GLFW_HAS_VULKAN (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwCreateWindowSurface
+#endif
+#define GLFW_HAS_FOCUS_WINDOW (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwFocusWindow
+#define GLFW_HAS_FOCUS_ON_SHOW (GLFW_VERSION_COMBINED >= 3300) // 3.3+ GLFW_FOCUS_ON_SHOW
+#define GLFW_HAS_MONITOR_WORK_AREA (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetMonitorWorkarea
+#define GLFW_HAS_OSX_WINDOW_POS_FIX (GLFW_VERSION_COMBINED >= 3301) // 3.3.1+ Fixed: Resizing window repositions it on MacOS #1553
#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?
#define GLFW_HAS_NEW_CURSORS (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
#else
#define GLFW_HAS_NEW_CURSORS (0)
#endif
+#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_COMBINED >= 3400) // 3.4+ GLFW_MOUSE_PASSTHROUGH
+#else
+#define GLFW_HAS_MOUSE_PASSTHROUGH (0)
+#endif
#define GLFW_HAS_GAMEPAD_API (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetGamepadState() new api
#define GLFW_HAS_GETKEYNAME (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwGetKeyName()
#define GLFW_HAS_GETERROR (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetError()
@@ -145,8 +168,10 @@
GLFWwindow* MouseWindow;
GLFWcursor* MouseCursors[ImGuiMouseCursor_COUNT];
ImVec2 LastValidMousePos;
+ GLFWwindow* KeyOwnerWindows[GLFW_KEY_LAST];
bool InstalledCallbacks;
bool CallbacksChainForAllWindows;
+ bool WantUpdateMonitors;
#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
const char* CanvasSelector;
#endif
@@ -179,6 +204,11 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplGlfw_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplGlfw_UpdateMonitors();
+static void ImGui_ImplGlfw_InitPlatformInterface();
+static void ImGui_ImplGlfw_ShutdownPlatformInterface();
+
// Functions
static ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int key)
{
@@ -394,6 +424,9 @@
ImGui_ImplGlfw_UpdateKeyModifiers(window);
+ if (keycode >= 0 && keycode < IM_ARRAYSIZE(bd->KeyOwnerWindows))
+ bd->KeyOwnerWindows[keycode] = (action == GLFW_PRESS) ? window : nullptr;
+
keycode = ImGui_ImplGlfw_TranslateUntranslatedKey(keycode, scancode);
ImGuiIO& io = ImGui::GetIO();
@@ -419,6 +452,13 @@
bd->PrevUserCallbackCursorPos(window, x, y);
ImGuiIO& io = ImGui::GetIO();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ int window_x, window_y;
+ glfwGetWindowPos(window, &window_x, &window_y);
+ x += window_x;
+ y += window_y;
+ }
io.AddMousePosEvent((float)x, (float)y);
bd->LastValidMousePos = ImVec2((float)x, (float)y);
}
@@ -457,7 +497,8 @@
void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor*, int)
{
- // Unused in 'master' branch but 'docking' branch will use this, so we declare it ahead of it so if you have to install callbacks you can install this one too.
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ bd->WantUpdateMonitors = true;
}
#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
@@ -479,32 +520,7 @@
#endif
#ifdef _WIN32
-// GLFW doesn't allow to distinguish Mouse vs TouchScreen vs Pen.
-// Add support for Win32 (based on imgui_impl_win32), because we rely on _TouchScreen info to trickle inputs differently.
-static ImGuiMouseSource GetMouseSourceFromMessageExtraInfo()
-{
- LPARAM extra_info = ::GetMessageExtraInfo();
- if ((extra_info & 0xFFFFFF80) == 0xFF515700)
- return ImGuiMouseSource_Pen;
- if ((extra_info & 0xFFFFFF80) == 0xFF515780)
- return ImGuiMouseSource_TouchScreen;
- return ImGuiMouseSource_Mouse;
-}
-static LRESULT CALLBACK ImGui_ImplGlfw_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{
- ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
- switch (msg)
- {
- case WM_MOUSEMOVE: case WM_NCMOUSEMOVE:
- case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK: case WM_LBUTTONUP:
- case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK: case WM_RBUTTONUP:
- case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK: case WM_MBUTTONUP:
- case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK: case WM_XBUTTONUP:
- ImGui::GetIO().AddMouseSourceEvent(GetMouseSourceFromMessageExtraInfo());
- break;
- }
- return ::CallWindowProcW(bd->PrevWndProc, hWnd, msg, wParam, lParam);
-}
+static LRESULT CALLBACK ImGui_ImplGlfw_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#endif
void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window)
@@ -580,9 +596,16 @@
io.BackendPlatformName = "imgui_impl_glfw";
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
+#ifndef __EMSCRIPTEN__
+ io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
+#endif
+#if GLFW_HAS_MOUSE_PASSTHROUGH || GLFW_HAS_WINDOW_HOVERED
+ io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can call io.AddMouseViewportEvent() with correct data (optional)
+#endif
bd->Window = window;
bd->Time = 0.0;
+ bd->WantUpdateMonitors = true;
ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
platform_io.Platform_SetClipboardTextFn = [](ImGuiContext*, const char* text) { glfwSetClipboardString(NULL, text); };
@@ -621,6 +644,10 @@
if (install_callbacks)
ImGui_ImplGlfw_InstallCallbacks(window);
+ // 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);
+
// Set platform dependent data in viewport
ImGuiViewport* main_viewport = ImGui::GetMainViewport();
main_viewport->PlatformHandle = (void*)bd->Window;
@@ -631,6 +658,8 @@
#else
IM_UNUSED(main_viewport);
#endif
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplGlfw_InitPlatformInterface();
// Windows: register a WndProc hook so we can intercept some messages.
#ifdef _WIN32
@@ -664,6 +693,8 @@
IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplGlfw_ShutdownPlatformInterface();
+
if (bd->InstalledCallbacks)
ImGui_ImplGlfw_RestoreCallbacks(bd->Window);
#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
@@ -683,7 +714,7 @@
io.BackendPlatformName = nullptr;
io.BackendPlatformUserData = nullptr;
- io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad);
+ io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_HasMouseHoveredViewport);
IM_DELETE(bd);
}
@@ -691,10 +722,15 @@
{
ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
ImGuiIO& io = ImGui::GetIO();
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
- // (those braces are here to reduce diff with multi-viewports support in 'docking' branch)
+ ImGuiID mouse_viewport_id = 0;
+ const ImVec2 mouse_pos_prev = io.MousePos;
+ for (int n = 0; n < platform_io.Viewports.Size; n++)
{
- GLFWwindow* window = bd->Window;
+ ImGuiViewport* viewport = platform_io.Viewports[n];
+ GLFWwindow* window = (GLFWwindow*)viewport->PlatformHandle;
+
#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
const bool is_window_focused = true;
#else
@@ -703,19 +739,54 @@
if (is_window_focused)
{
// (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)io.MousePos.x, (double)io.MousePos.y);
+ glfwSetCursorPos(window, (double)(mouse_pos_prev.x - viewport->Pos.x), (double)(mouse_pos_prev.y - viewport->Pos.y));
// (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
if (bd->MouseWindow == nullptr)
{
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;
+ }
bd->LastValidMousePos = ImVec2((float)mouse_x, (float)mouse_y);
io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
}
}
+
+ // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
+ // 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 (since we implement hit via our WndProc hook)
+ // On other platforms we rely on the library fallbacking to its own search when reporting a viewport with _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.
+ // See https://github.com/glfw/glfw/issues/1236 if you want to help in making this a GLFW feature.
+#if GLFW_HAS_MOUSE_PASSTHROUGH
+ const bool window_no_input = (viewport->Flags & ImGuiViewportFlags_NoInputs) != 0;
+ glfwSetWindowAttrib(window, GLFW_MOUSE_PASSTHROUGH, window_no_input);
+#endif
+#if GLFW_HAS_MOUSE_PASSTHROUGH || GLFW_HAS_WINDOW_HOVERED
+ if (glfwGetWindowAttrib(window, GLFW_HOVERED))
+ mouse_viewport_id = viewport->ID;
+#else
+ // We cannot use bd->MouseWindow maintained from CursorEnter/Leave callbacks, because it is locked to the window capturing mouse.
+#endif
}
+
+ if (io.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
+ io.AddMouseViewportEvent(mouse_viewport_id);
}
static void ImGui_ImplGlfw_UpdateMouseCursor()
@@ -726,9 +797,10 @@
return;
ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
- // (those braces are here to reduce diff with multi-viewports support in 'docking' branch)
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int n = 0; n < platform_io.Viewports.Size; n++)
{
- GLFWwindow* window = bd->Window;
+ GLFWwindow* window = (GLFWwindow*)platform_io.Viewports[n]->PlatformHandle;
if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
@@ -797,6 +869,50 @@
#undef MAP_ANALOG
}
+static void ImGui_ImplGlfw_UpdateMonitors()
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ bd->WantUpdateMonitors = false;
+
+ int monitors_count = 0;
+ GLFWmonitor** glfw_monitors = glfwGetMonitors(&monitors_count);
+ if (monitors_count == 0) // Preserve existing monitor list if there are none. Happens on macOS sleeping (#5683)
+ return;
+
+ 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]);
+ if (vid_mode == nullptr)
+ continue; // Failed to get Video mode (e.g. Emscripten does not support this function)
+ monitor.MainPos = monitor.WorkPos = ImVec2((float)x, (float)y);
+ monitor.MainSize = monitor.WorkSize = ImVec2((float)vid_mode->width, (float)vid_mode->height);
+#if GLFW_HAS_MONITOR_WORK_AREA
+ int w, h;
+ glfwGetMonitorWorkarea(glfw_monitors[n], &x, &y, &w, &h);
+ 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);
+ }
+#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);
+ if (x_scale == 0.0f)
+ continue; // Some accessibility applications are declaring virtual monitors with a DPI of 0, see #7902.
+ monitor.DpiScale = x_scale;
+#endif
+ monitor.PlatformHandle = (void*)glfw_monitors[n]; // [...] GLFW doc states: "guaranteed to be valid only until the monitor configuration changes"
+ platform_io.Monitors.push_back(monitor);
+ }
+}
+
void ImGui_ImplGlfw_NewFrame()
{
ImGuiIO& io = ImGui::GetIO();
@@ -811,6 +927,8 @@
io.DisplaySize = ImVec2((float)w, (float)h);
if (w > 0 && h > 0)
io.DisplayFramebufferScale = ImVec2((float)display_w / (float)w, (float)display_h / (float)h);
+ if (bd->WantUpdateMonitors)
+ ImGui_ImplGlfw_UpdateMonitors();
// Setup time step
// (Accept glfwGetTime() not returning a monotonically increasing value. Seems to happens on disconnecting peripherals and probably on VMs and Emscripten, see #6491, #6189, #6114, #3644)
@@ -889,6 +1007,399 @@
}
#endif // #ifdef EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3
+
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplGlfw_ViewportData
+{
+ GLFWwindow* Window;
+ bool WindowOwned;
+ int IgnoreWindowPosEventFrame;
+ int IgnoreWindowSizeEventFrame;
+#ifdef _WIN32
+ WNDPROC PrevWndProc;
+#endif
+
+ ImGui_ImplGlfw_ViewportData() { memset(this, 0, sizeof(*this)); IgnoreWindowSizeEventFrame = IgnoreWindowPosEventFrame = -1; }
+ ~ImGui_ImplGlfw_ViewportData() { IM_ASSERT(Window == nullptr); }
+};
+
+static void ImGui_ImplGlfw_WindowCloseCallback(GLFWwindow* window)
+{
+ if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
+ viewport->PlatformRequestClose = true;
+}
+
+// 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.
+static void ImGui_ImplGlfw_WindowPosCallback(GLFWwindow* window, int, int)
+{
+ if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
+ {
+ if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
+ {
+ bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowPosEventFrame + 1);
+ //data->IgnoreWindowPosEventFrame = -1;
+ if (ignore_event)
+ return;
+ }
+ viewport->PlatformRequestMove = true;
+ }
+}
+
+static void ImGui_ImplGlfw_WindowSizeCallback(GLFWwindow* window, int, int)
+{
+ if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle(window))
+ {
+ if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
+ {
+ bool ignore_event = (ImGui::GetFrameCount() <= vd->IgnoreWindowSizeEventFrame + 1);
+ //data->IgnoreWindowSizeEventFrame = -1;
+ if (ignore_event)
+ return;
+ }
+ viewport->PlatformRequestResize = true;
+ }
+}
+
+static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
+ viewport->PlatformUserData = vd;
+
+ // GLFW 3.2 unfortunately always set focus on glfwCreateWindow() if GLFW_VISIBLE is set, regardless of GLFW_FOCUSED
+ // With GLFW 3.3, the hint GLFW_FOCUS_ON_SHOW fixes this problem
+ glfwWindowHint(GLFW_VISIBLE, false);
+ glfwWindowHint(GLFW_FOCUSED, false);
+#if GLFW_HAS_FOCUS_ON_SHOW
+ glfwWindowHint(GLFW_FOCUS_ON_SHOW, false);
+ #endif
+ glfwWindowHint(GLFW_DECORATED, (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? false : true);
+#if GLFW_HAS_WINDOW_TOPMOST
+ glfwWindowHint(GLFW_FLOATING, (viewport->Flags & ImGuiViewportFlags_TopMost) ? true : false);
+#endif
+ GLFWwindow* share_window = (bd->ClientApi == GlfwClientApi_OpenGL) ? bd->Window : nullptr;
+ vd->Window = glfwCreateWindow((int)viewport->Size.x, (int)viewport->Size.y, "No Title Yet", nullptr, share_window);
+ vd->WindowOwned = true;
+ viewport->PlatformHandle = (void*)vd->Window;
+#ifdef _WIN32
+ viewport->PlatformHandleRaw = glfwGetWin32Window(vd->Window);
+#elif defined(__APPLE__)
+ viewport->PlatformHandleRaw = (void*)glfwGetCocoaWindow(vd->Window);
+#endif
+ glfwSetWindowPos(vd->Window, (int)viewport->Pos.x, (int)viewport->Pos.y);
+
+ // Install GLFW callbacks for secondary viewports
+ glfwSetWindowFocusCallback(vd->Window, ImGui_ImplGlfw_WindowFocusCallback);
+ glfwSetCursorEnterCallback(vd->Window, ImGui_ImplGlfw_CursorEnterCallback);
+ glfwSetCursorPosCallback(vd->Window, ImGui_ImplGlfw_CursorPosCallback);
+ 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);
+ if (bd->ClientApi == GlfwClientApi_OpenGL)
+ {
+ glfwMakeContextCurrent(vd->Window);
+ glfwSwapInterval(0);
+ }
+}
+
+static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
+ {
+ if (vd->WindowOwned)
+ {
+#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
+ HWND hwnd = (HWND)viewport->PlatformHandleRaw;
+ ::RemovePropA(hwnd, "IMGUI_VIEWPORT");
+#endif
+
+ // 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.
+ for (int i = 0; i < IM_ARRAYSIZE(bd->KeyOwnerWindows); i++)
+ 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.
+
+ glfwDestroyWindow(vd->Window);
+ }
+ vd->Window = nullptr;
+ IM_DELETE(vd);
+ }
+ viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
+}
+
+static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+
+#if defined(_WIN32)
+ // GLFW hack: Hide icon from task bar
+ HWND hwnd = (HWND)viewport->PlatformHandleRaw;
+ if (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon)
+ {
+ 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
+#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED && defined(_WIN32)
+ ::SetPropA(hwnd, "IMGUI_VIEWPORT", viewport);
+ vd->PrevWndProc = (WNDPROC)::GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
+ ::SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)ImGui_ImplGlfw_WndProc);
+#endif
+
+#if !GLFW_HAS_FOCUS_ON_SHOW
+ // GLFW hack: GLFW 3.2 has a bug where glfwShowWindow() also activates/focus the window.
+ // 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.
+ if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
+ {
+ ::ShowWindow(hwnd, SW_SHOWNA);
+ return;
+ }
+#endif
+#endif
+
+ glfwShowWindow(vd->Window);
+}
+
+static ImVec2 ImGui_ImplGlfw_GetWindowPos(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ int x = 0, y = 0;
+ glfwGetWindowPos(vd->Window, &x, &y);
+ return ImVec2((float)x, (float)y);
+}
+
+static void ImGui_ImplGlfw_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ vd->IgnoreWindowPosEventFrame = ImGui::GetFrameCount();
+ glfwSetWindowPos(vd->Window, (int)pos.x, (int)pos.y);
+}
+
+static ImVec2 ImGui_ImplGlfw_GetWindowSize(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ int w = 0, h = 0;
+ glfwGetWindowSize(vd->Window, &w, &h);
+ return ImVec2((float)w, (float)h);
+}
+
+static void ImGui_ImplGlfw_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+#if __APPLE__ && !GLFW_HAS_OSX_WINDOW_POS_FIX
+ // 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;
+ glfwGetWindowPos(vd->Window, &x, &y);
+ glfwGetWindowSize(vd->Window, &width, &height);
+ glfwSetWindowPos(vd->Window, x, y - height + size.y);
+#endif
+ vd->IgnoreWindowSizeEventFrame = ImGui::GetFrameCount();
+ glfwSetWindowSize(vd->Window, (int)size.x, (int)size.y);
+}
+
+static void ImGui_ImplGlfw_SetWindowTitle(ImGuiViewport* viewport, const char* title)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ glfwSetWindowTitle(vd->Window, title);
+}
+
+static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport)
+{
+#if GLFW_HAS_FOCUS_WINDOW
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ glfwFocusWindow(vd->Window);
+#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
+}
+
+static bool ImGui_ImplGlfw_GetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ return glfwGetWindowAttrib(vd->Window, GLFW_FOCUSED) != 0;
+}
+
+static bool ImGui_ImplGlfw_GetWindowMinimized(ImGuiViewport* viewport)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ return glfwGetWindowAttrib(vd->Window, GLFW_ICONIFIED) != 0;
+}
+
+#if GLFW_HAS_WINDOW_ALPHA
+static void ImGui_ImplGlfw_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
+{
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ glfwSetWindowOpacity(vd->Window, alpha);
+}
+#endif
+
+static void ImGui_ImplGlfw_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ if (bd->ClientApi == GlfwClientApi_OpenGL)
+ glfwMakeContextCurrent(vd->Window);
+}
+
+static void ImGui_ImplGlfw_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ if (bd->ClientApi == GlfwClientApi_OpenGL)
+ {
+ glfwMakeContextCurrent(vd->Window);
+ glfwSwapBuffers(vd->Window);
+ }
+}
+
+//--------------------------------------------------------------------------------------------------------
+// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
+//--------------------------------------------------------------------------------------------------------
+
+// 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)
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData;
+ IM_UNUSED(bd);
+ IM_ASSERT(bd->ClientApi == GlfwClientApi_Vulkan);
+ VkResult err = glfwCreateWindowSurface((VkInstance)vk_instance, vd->Window, (const VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface);
+ return (int)err;
+}
+#endif // GLFW_HAS_VULKAN
+
+static void ImGui_ImplGlfw_InitPlatformInterface()
+{
+ // Register platform interface (will be coupled with a renderer interface)
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ 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;
+ platform_io.Platform_SetWindowFocus = ImGui_ImplGlfw_SetWindowFocus;
+ platform_io.Platform_GetWindowFocus = ImGui_ImplGlfw_GetWindowFocus;
+ platform_io.Platform_GetWindowMinimized = ImGui_ImplGlfw_GetWindowMinimized;
+ platform_io.Platform_SetWindowTitle = ImGui_ImplGlfw_SetWindowTitle;
+ platform_io.Platform_RenderWindow = ImGui_ImplGlfw_RenderWindow;
+ platform_io.Platform_SwapBuffers = ImGui_ImplGlfw_SwapBuffers;
+#if GLFW_HAS_WINDOW_ALPHA
+ platform_io.Platform_SetWindowAlpha = ImGui_ImplGlfw_SetWindowAlpha;
+#endif
+#if GLFW_HAS_VULKAN
+ platform_io.Platform_CreateVkSurface = ImGui_ImplGlfw_CreateVkSurface;
+#endif
+
+ // Register main window handle (which is owned by the main application, not by us)
+ // 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.
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGui_ImplGlfw_ViewportData* vd = IM_NEW(ImGui_ImplGlfw_ViewportData)();
+ vd->Window = bd->Window;
+ vd->WindowOwned = false;
+ main_viewport->PlatformUserData = vd;
+ main_viewport->PlatformHandle = (void*)bd->Window;
+}
+
+static void ImGui_ImplGlfw_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
+//-----------------------------------------------------------------------------
+
+// WndProc hook (declared here because we will need access to ImGui_ImplGlfw_ViewportData)
+#ifdef _WIN32
+static ImGuiMouseSource GetMouseSourceFromMessageExtraInfo()
+{
+ LPARAM extra_info = ::GetMessageExtraInfo();
+ if ((extra_info & 0xFFFFFF80) == 0xFF515700)
+ return ImGuiMouseSource_Pen;
+ if ((extra_info & 0xFFFFFF80) == 0xFF515780)
+ return ImGuiMouseSource_TouchScreen;
+ return ImGuiMouseSource_Mouse;
+}
+static LRESULT CALLBACK ImGui_ImplGlfw_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+ WNDPROC prev_wndproc = bd->PrevWndProc;
+ ImGuiViewport* viewport = (ImGuiViewport*)::GetPropA(hWnd, "IMGUI_VIEWPORT");
+ if (viewport != NULL)
+ if (ImGui_ImplGlfw_ViewportData* vd = (ImGui_ImplGlfw_ViewportData*)viewport->PlatformUserData)
+ prev_wndproc = vd->PrevWndProc;
+
+ switch (msg)
+ {
+ // GLFW doesn't allow to distinguish Mouse vs TouchScreen vs Pen.
+ // Add support for Win32 (based on imgui_impl_win32), because we rely on _TouchScreen info to trickle inputs differently.
+ case WM_MOUSEMOVE: case WM_NCMOUSEMOVE:
+ case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK: case WM_LBUTTONUP:
+ case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK: case WM_RBUTTONUP:
+ case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK: case WM_MBUTTONUP:
+ case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK: case WM_XBUTTONUP:
+ ImGui::GetIO().AddMouseSourceEvent(GetMouseSourceFromMessageExtraInfo());
+ break;
+
+ // 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!)
+#if !GLFW_HAS_MOUSE_PASSTHROUGH && GLFW_HAS_WINDOW_HOVERED
+ case WM_NCHITTEST:
+ {
+ // Let mouse pass-through the window. This will allow the backend to call io.AddMouseViewportEvent() properly (which is OPTIONAL).
+ // 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
+ // your main loop after calling UpdatePlatformWindows(). Iterate all viewports/platform windows and pass the flag to your windowing system.
+ if (viewport && (viewport->Flags & ImGuiViewportFlags_NoInputs))
+ return HTTRANSPARENT;
+ break;
+ }
+#endif
+ }
+ return ::CallWindowProcW(prev_wndproc, hWnd, msg, wParam, lParam);
+}
+#endif // #ifdef _WIN32
+
//-----------------------------------------------------------------------------
#if defined(__clang__)
diff --git a/backends/imgui_impl_glfw.h b/backends/imgui_impl_glfw.h
index 60b95bd..03856dc 100644
--- a/backends/imgui_impl_glfw.h
+++ b/backends/imgui_impl_glfw.h
@@ -1,6 +1,7 @@
// dear imgui: Platform Backend for GLFW
// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
+// (Requires: GLFW 3.1+. Prefer GLFW 3.3+ for full feature support.)
// Implemented features:
// [X] Platform: Clipboard support.
@@ -8,6 +9,9 @@
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
+// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+// Issues:
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_glut.cpp b/backends/imgui_impl_glut.cpp
index d8ffc90..0678603 100644
--- a/backends/imgui_impl_glut.cpp
+++ b/backends/imgui_impl_glut.cpp
@@ -7,7 +7,7 @@
// Implemented features:
// [X] Platform: Partial 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 GLUT values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
-// Issues:
+// Missing features:
// [ ] Platform: GLUT is unable to distinguish e.g. Backspace from CTRL+H or TAB from CTRL+I
// [ ] Platform: Missing horizontal mouse wheel support.
// [ ] Platform: Missing mouse cursor shape/visibility support.
diff --git a/backends/imgui_impl_glut.h b/backends/imgui_impl_glut.h
index a7479e1..54e4253 100644
--- a/backends/imgui_impl_glut.h
+++ b/backends/imgui_impl_glut.h
@@ -7,7 +7,7 @@
// Implemented features:
// [X] Platform: Partial 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 GLUT values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
-// Issues:
+// Missing features:
// [ ] Platform: GLUT is unable to distinguish e.g. Backspace from CTRL+H or TAB from CTRL+I
// [ ] Platform: Missing horizontal mouse wheel support.
// [ ] Platform: Missing mouse cursor shape/visibility support.
diff --git a/backends/imgui_impl_metal.h b/backends/imgui_impl_metal.h
index 2402c02..c6d15e4 100644
--- a/backends/imgui_impl_metal.h
+++ b/backends/imgui_impl_metal.h
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'MTLTexture' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_metal.mm b/backends/imgui_impl_metal.mm
index f9fd108..22aa37e 100644
--- a/backends/imgui_impl_metal.mm
+++ b/backends/imgui_impl_metal.mm
@@ -4,6 +4,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'MTLTexture' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -15,6 +16,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Metal: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2022-08-23: Metal: Update deprecated property 'sampleCount'->'rasterSampleCount'.
// 2022-07-05: Metal: Add dispatch synchronization.
// 2022-06-30: Metal: Use __bridge for ARC based systems.
@@ -38,6 +40,12 @@
#import <time.h>
#import <Metal/Metal.h>
+// Forward Declarations
+static void ImGui_ImplMetal_InitPlatformInterface();
+static void ImGui_ImplMetal_ShutdownPlatformInterface();
+static void ImGui_ImplMetal_CreateDeviceObjectsForPlatformWindows();
+static void ImGui_ImplMetal_InvalidateDeviceObjectsForPlatformWindows();
+
#pragma mark - Support classes
// A wrapper around a MTLBuffer object that knows the last time it was reused
@@ -132,10 +140,14 @@
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_metal";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
bd->SharedMetalContext = [[MetalContext alloc] init];
bd->SharedMetalContext.device = device;
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplMetal_InitPlatformInterface();
+
return true;
}
@@ -143,13 +155,14 @@
{
ImGui_ImplMetal_Data* bd = ImGui_ImplMetal_GetBackendData();
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
+ ImGui_ImplMetal_ShutdownPlatformInterface();
ImGui_ImplMetal_DestroyDeviceObjects();
ImGui_ImplMetal_DestroyBackendData();
ImGuiIO& io = ImGui::GetIO();
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
}
void ImGui_ImplMetal_NewFrame(MTLRenderPassDescriptor* renderPassDescriptor)
@@ -367,6 +380,7 @@
depthStencilDescriptor.depthWriteEnabled = NO;
depthStencilDescriptor.depthCompareFunction = MTLCompareFunctionAlways;
bd->SharedMetalContext.depthStencilState = [device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
+ ImGui_ImplMetal_CreateDeviceObjectsForPlatformWindows();
ImGui_ImplMetal_CreateFontsTexture(device);
return true;
@@ -376,9 +390,155 @@
{
ImGui_ImplMetal_Data* bd = ImGui_ImplMetal_GetBackendData();
ImGui_ImplMetal_DestroyFontsTexture();
+ ImGui_ImplMetal_InvalidateDeviceObjectsForPlatformWindows();
[bd->SharedMetalContext.renderPipelineStateCache removeAllObjects];
}
+#pragma mark - Multi-viewport support
+
+#import <QuartzCore/CAMetalLayer.h>
+
+#if TARGET_OS_OSX
+#import <Cocoa/Cocoa.h>
+#endif
+
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the back-end to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+struct ImGuiViewportDataMetal
+{
+ CAMetalLayer* MetalLayer;
+ id<MTLCommandQueue> CommandQueue;
+ MTLRenderPassDescriptor* RenderPassDescriptor;
+ void* Handle = nullptr;
+ bool FirstFrame = true;
+};
+
+static void ImGui_ImplMetal_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplMetal_Data* bd = ImGui_ImplMetal_GetBackendData();
+ ImGuiViewportDataMetal* data = IM_NEW(ImGuiViewportDataMetal)();
+ viewport->RendererUserData = data;
+
+ // PlatformHandleRaw should always be a NSWindow*, whereas PlatformHandle might be a higher-level handle (e.g. GLFWWindow*, SDL_Window*).
+ // Some back-ends will leave PlatformHandleRaw == 0, in which case we assume PlatformHandle will contain the NSWindow*.
+ void* handle = viewport->PlatformHandleRaw ? viewport->PlatformHandleRaw : viewport->PlatformHandle;
+ IM_ASSERT(handle != nullptr);
+
+ id<MTLDevice> device = bd->SharedMetalContext.device;
+ CAMetalLayer* layer = [CAMetalLayer layer];
+ layer.device = device;
+ layer.framebufferOnly = YES;
+ layer.pixelFormat = bd->SharedMetalContext.framebufferDescriptor.colorPixelFormat;
+#if TARGET_OS_OSX
+ NSWindow* window = (__bridge NSWindow*)handle;
+ NSView* view = window.contentView;
+ view.layer = layer;
+ view.wantsLayer = YES;
+#endif
+ data->MetalLayer = layer;
+ data->CommandQueue = [device newCommandQueue];
+ data->RenderPassDescriptor = [[MTLRenderPassDescriptor alloc] init];
+ data->Handle = handle;
+}
+
+static void ImGui_ImplMetal_DestroyWindow(ImGuiViewport* viewport)
+{
+ // The main viewport (owned by the application) will always have RendererUserData == 0 since we didn't create the data for it.
+ if (ImGuiViewportDataMetal* data = (ImGuiViewportDataMetal*)viewport->RendererUserData)
+ IM_DELETE(data);
+ viewport->RendererUserData = nullptr;
+}
+
+inline static CGSize MakeScaledSize(CGSize size, CGFloat scale)
+{
+ return CGSizeMake(size.width * scale, size.height * scale);
+}
+
+static void ImGui_ImplMetal_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGuiViewportDataMetal* data = (ImGuiViewportDataMetal*)viewport->RendererUserData;
+ data->MetalLayer.drawableSize = MakeScaledSize(CGSizeMake(size.x, size.y), viewport->DpiScale);
+}
+
+static void ImGui_ImplMetal_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGuiViewportDataMetal* data = (ImGuiViewportDataMetal*)viewport->RendererUserData;
+
+#if TARGET_OS_OSX
+ void* handle = viewport->PlatformHandleRaw ? viewport->PlatformHandleRaw : viewport->PlatformHandle;
+ NSWindow* window = (__bridge NSWindow*)handle;
+
+ // Always render the first frame, regardless of occlusionState, to avoid an initial flicker
+ if ((window.occlusionState & NSWindowOcclusionStateVisible) == 0 && !data->FirstFrame)
+ {
+ // Do not render windows which are completely occluded. Calling -[CAMetalLayer nextDrawable] will hang for
+ // approximately 1 second if the Metal layer is completely occluded.
+ return;
+ }
+ data->FirstFrame = false;
+
+ viewport->DpiScale = (float)window.backingScaleFactor;
+ if (data->MetalLayer.contentsScale != viewport->DpiScale)
+ {
+ data->MetalLayer.contentsScale = viewport->DpiScale;
+ data->MetalLayer.drawableSize = MakeScaledSize(window.frame.size, viewport->DpiScale);
+ }
+ viewport->DrawData->FramebufferScale = ImVec2(viewport->DpiScale, viewport->DpiScale);
+#endif
+
+ id <CAMetalDrawable> drawable = [data->MetalLayer nextDrawable];
+ if (drawable == nil)
+ return;
+
+ MTLRenderPassDescriptor* renderPassDescriptor = data->RenderPassDescriptor;
+ renderPassDescriptor.colorAttachments[0].texture = drawable.texture;
+ renderPassDescriptor.colorAttachments[0].clearColor = MTLClearColorMake(0, 0, 0, 0);
+ if ((viewport->Flags & ImGuiViewportFlags_NoRendererClear) == 0)
+ renderPassDescriptor.colorAttachments[0].loadAction = MTLLoadActionClear;
+
+ id <MTLCommandBuffer> commandBuffer = [data->CommandQueue commandBuffer];
+ id <MTLRenderCommandEncoder> renderEncoder = [commandBuffer renderCommandEncoderWithDescriptor:renderPassDescriptor];
+ ImGui_ImplMetal_RenderDrawData(viewport->DrawData, commandBuffer, renderEncoder);
+ [renderEncoder endEncoding];
+
+ [commandBuffer presentDrawable:drawable];
+ [commandBuffer commit];
+}
+
+static void ImGui_ImplMetal_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_CreateWindow = ImGui_ImplMetal_CreateWindow;
+ platform_io.Renderer_DestroyWindow = ImGui_ImplMetal_DestroyWindow;
+ platform_io.Renderer_SetWindowSize = ImGui_ImplMetal_SetWindowSize;
+ platform_io.Renderer_RenderWindow = ImGui_ImplMetal_RenderWindow;
+}
+
+static void ImGui_ImplMetal_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
+static void ImGui_ImplMetal_CreateDeviceObjectsForPlatformWindows()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int i = 1; i < platform_io.Viewports.Size; i++)
+ if (!platform_io.Viewports[i]->RendererUserData)
+ ImGui_ImplMetal_CreateWindow(platform_io.Viewports[i]);
+}
+
+static void ImGui_ImplMetal_InvalidateDeviceObjectsForPlatformWindows()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int i = 1; i < platform_io.Viewports.Size; i++)
+ if (platform_io.Viewports[i]->RendererUserData)
+ ImGui_ImplMetal_DestroyWindow(platform_io.Viewports[i]);
+}
+
#pragma mark - MetalBuffer implementation
@implementation MetalBuffer
diff --git a/backends/imgui_impl_opengl2.cpp b/backends/imgui_impl_opengl2.cpp
index 7f1ea32..51ea82c 100644
--- a/backends/imgui_impl_opengl2.cpp
+++ b/backends/imgui_impl_opengl2.cpp
@@ -3,6 +3,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -22,6 +23,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-06-28: OpenGL: ImGui_ImplOpenGL2_NewFrame() recreates font texture if it has been destroyed by ImGui_ImplOpenGL2_DestroyFontsTexture(). (#7748)
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
// 2021-12-08: OpenGL: Fixed mishandling of the ImDrawCmd::IdxOffset field! This is an old bug but it never had an effect until some internal rendering changes in 1.86.
@@ -80,6 +82,10 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplOpenGL2_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplOpenGL2_InitPlatformInterface();
+static void ImGui_ImplOpenGL2_ShutdownPlatformInterface();
+
// Functions
bool ImGui_ImplOpenGL2_Init()
{
@@ -91,6 +97,10 @@
ImGui_ImplOpenGL2_Data* bd = IM_NEW(ImGui_ImplOpenGL2_Data)();
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_opengl2";
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
+
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplOpenGL2_InitPlatformInterface();
return true;
}
@@ -101,9 +111,11 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplOpenGL2_ShutdownPlatformInterface();
ImGui_ImplOpenGL2_DestroyDeviceObjects();
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
+ io.BackendFlags &= ~ImGuiBackendFlags_RendererHasViewports;
IM_DELETE(bd);
}
@@ -297,6 +309,35 @@
ImGui_ImplOpenGL2_DestroyFontsTexture();
}
+
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+static void ImGui_ImplOpenGL2_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+ {
+ ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+ glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
+ glClear(GL_COLOR_BUFFER_BIT);
+ }
+ ImGui_ImplOpenGL2_RenderDrawData(viewport->DrawData);
+}
+
+static void ImGui_ImplOpenGL2_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_RenderWindow = ImGui_ImplOpenGL2_RenderWindow;
+}
+
+static void ImGui_ImplOpenGL2_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#if defined(__clang__)
diff --git a/backends/imgui_impl_opengl2.h b/backends/imgui_impl_opengl2.h
index e7f7a58..cc9b688 100644
--- a/backends/imgui_impl_opengl2.h
+++ b/backends/imgui_impl_opengl2.h
@@ -3,6 +3,7 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_opengl3.cpp b/backends/imgui_impl_opengl3.cpp
index 7087a7c..770f85f 100644
--- a/backends/imgui_impl_opengl3.cpp
+++ b/backends/imgui_impl_opengl3.cpp
@@ -5,7 +5,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
-// [x] Renderer: Large meshes support (64k+ vertices) with 16-bit indices (Desktop OpenGL only).
+// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices (Desktop OpenGL only).
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// About WebGL/ES:
// - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
@@ -22,6 +23,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-06-28: OpenGL: ImGui_ImplOpenGL3_NewFrame() recreates font texture if it has been destroyed by ImGui_ImplOpenGL3_DestroyFontsTexture(). (#7748)
// 2024-05-07: OpenGL: Update loader for Linux to support EGL/GLVND. (#7562)
// 2024-04-16: OpenGL: Detect ES3 contexts on desktop based on version string, to e.g. avoid calling glPolygonMode() on them. (#7447)
@@ -249,6 +251,10 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplOpenGL3_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplOpenGL3_InitPlatformInterface();
+static void ImGui_ImplOpenGL3_ShutdownPlatformInterface();
+
// OpenGL vertex attribute state (for ES 1.0 and ES 2.0 only)
#ifndef IMGUI_IMPL_OPENGL_USE_VERTEX_ARRAY
struct ImGui_ImplOpenGL3_VtxAttribState
@@ -341,6 +347,7 @@
if (bd->GlVersion >= 320)
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
#endif
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
// Store GLSL version string so we can refer to it later in case we recreate shaders.
// Note: GLSL version is NOT the same as GL version. Leave this to nullptr if unsure.
@@ -381,6 +388,9 @@
}
#endif
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplOpenGL3_InitPlatformInterface();
+
return true;
}
@@ -390,10 +400,11 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplOpenGL3_ShutdownPlatformInterface();
ImGui_ImplOpenGL3_DestroyDeviceObjects();
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
IM_DELETE(bd);
}
@@ -949,6 +960,34 @@
ImGui_ImplOpenGL3_DestroyFontsTexture();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+static void ImGui_ImplOpenGL3_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ if (!(viewport->Flags & ImGuiViewportFlags_NoRendererClear))
+ {
+ ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+ glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
+ glClear(GL_COLOR_BUFFER_BIT);
+ }
+ ImGui_ImplOpenGL3_RenderDrawData(viewport->DrawData);
+}
+
+static void ImGui_ImplOpenGL3_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Renderer_RenderWindow = ImGui_ImplOpenGL3_RenderWindow;
+}
+
+static void ImGui_ImplOpenGL3_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#if defined(__GNUC__)
diff --git a/backends/imgui_impl_opengl3.h b/backends/imgui_impl_opengl3.h
index 54545f9..7b1e98d 100644
--- a/backends/imgui_impl_opengl3.h
+++ b/backends/imgui_impl_opengl3.h
@@ -5,7 +5,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
-// [x] Renderer: Large meshes support (64k+ vertices) with 16-bit indices (Desktop OpenGL only).
+// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices (Desktop OpenGL only).
+// [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// About WebGL/ES:
// - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
diff --git a/backends/imgui_impl_osx.h b/backends/imgui_impl_osx.h
index 28e1331..e541655 100644
--- a/backends/imgui_impl_osx.h
+++ b/backends/imgui_impl_osx.h
@@ -10,6 +10,10 @@
// [X] Platform: OSX clipboard is supported within core Dear ImGui (no specific code in this backend).
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: IME support.
+// [x] Platform: Multi-viewport / platform windows.
+// Issues:
+// [ ] Platform: Multi-viewport: Window size not correctly reported when enabling io.ConfigViewportsNoDecoration
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_osx.mm b/backends/imgui_impl_osx.mm
index 870038d..9070f96 100644
--- a/backends/imgui_impl_osx.mm
+++ b/backends/imgui_impl_osx.mm
@@ -10,6 +10,10 @@
// [X] Platform: OSX clipboard is supported within core Dear ImGui (no specific code in this backend).
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: IME support.
+// [x] Platform: Multi-viewport / platform windows.
+// Issues:
+// [ ] Platform: Multi-viewport: Window size not correctly reported when enabling io.ConfigViewportsNoDecoration
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -29,6 +33,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-08-22: moved some OS/backend related function pointers from ImGuiIO to ImGuiPlatformIO:
// - io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn
// - io.SetClipboardTextFn -> platform_io.Platform_SetClipboardTextFn
@@ -96,6 +101,9 @@
static inline CFTimeInterval GetMachAbsoluteTimeInSeconds() { return (CFTimeInterval)(double)(clock_gettime_nsec_np(CLOCK_UPTIME_RAW) / 1e9); }
// Forward Declarations
+static void ImGui_ImplOSX_InitPlatformInterface();
+static void ImGui_ImplOSX_ShutdownPlatformInterface();
+static void ImGui_ImplOSX_UpdateMonitors();
static void ImGui_ImplOSX_AddTrackingArea(NSView* _Nonnull view);
static bool ImGui_ImplOSX_HandleEvent(NSEvent* event, NSView* view);
@@ -142,9 +150,25 @@
NSWindow* window = view.window;
if (!window)
return;
- NSRect contentRect = [window contentRectForFrameRect:window.frame];
- NSRect rect = NSMakeRect(_posX, contentRect.size.height - _posY, 0, 0);
- _imeRect = [window convertRectToScreen:rect];
+
+ ImGuiIO& io = ImGui::GetIO();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ NSRect frame = window.frame;
+ NSRect contentRect = window.contentLayoutRect;
+ if (window.styleMask & NSWindowStyleMaskFullSizeContentView) // No title bar windows should be considered.
+ contentRect = frame;
+
+ NSRect firstScreenFrame = NSScreen.screens[0].frame;
+ _imeRect = NSMakeRect(_posX, _posY, 0, 0);
+ _imeRect.origin.y = firstScreenFrame.size.height - _imeRect.size.height - _imeRect.origin.y; // Opposite of ConvertNSRect()
+ }
+ else
+ {
+ NSRect contentRect = [window contentRectForFrameRect:window.frame];
+ NSRect rect = NSMakeRect(_posX, contentRect.size.height - _posY, 0, 0);
+ _imeRect = [window convertRectToScreen:rect];
+ }
}
- (void)viewDidMoveToWindow
@@ -239,6 +263,7 @@
- (void)onApplicationBecomeActive:(NSNotification*)aNotification;
- (void)onApplicationBecomeInactive:(NSNotification*)aNotification;
+- (void)displaysDidChange:(NSNotification*)aNotification;
@end
@@ -256,6 +281,11 @@
io.AddFocusEvent(false);
}
+- (void)displaysDidChange:(NSNotification*)aNotification
+{
+ ImGui_ImplOSX_UpdateMonitors();
+}
+
@end
// Functions
@@ -407,11 +437,16 @@
io.BackendPlatformName = "imgui_impl_osx";
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
//io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
+ io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
+ //io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can call io.AddMouseViewportEvent() with correct data (optional)
bd->Observer = [ImGuiObserver new];
bd->Window = view.window ?: NSApp.orderedWindows.firstObject;
ImGuiViewport* main_viewport = ImGui::GetMainViewport();
main_viewport->PlatformHandle = main_viewport->PlatformHandleRaw = (__bridge_retained void*)bd->Window;
+ ImGui_ImplOSX_UpdateMonitors();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplOSX_InitPlatformInterface();
// Load cursors. Some of them are undocumented.
bd->MouseCursorHidden = false;
@@ -501,12 +536,12 @@
bd->Monitor = nullptr;
}
+ ImGui_ImplOSX_ShutdownPlatformInterface();
ImGui_ImplOSX_DestroyBackendData();
-
ImGuiIO& io = ImGui::GetIO();
io.BackendPlatformName = nullptr;
io.BackendPlatformUserData = nullptr;
- io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasGamepad);
+ io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports);
}
static void ImGui_ImplOSX_UpdateMouseCursor()
@@ -683,14 +718,23 @@
if (event.type == NSEventTypeMouseMoved || event.type == NSEventTypeLeftMouseDragged || event.type == NSEventTypeRightMouseDragged || event.type == NSEventTypeOtherMouseDragged)
{
- NSPoint mousePoint = event.locationInWindow;
- if (event.window == nil)
- mousePoint = [[view window] convertPointFromScreen:mousePoint];
- mousePoint = [view convertPoint:mousePoint fromView:nil];
- if ([view isFlipped])
- mousePoint = NSMakePoint(mousePoint.x, mousePoint.y);
+ NSPoint mousePoint;
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ mousePoint = NSEvent.mouseLocation;
+ mousePoint.y = CGDisplayPixelsHigh(kCGDirectMainDisplay) - mousePoint.y; // Normalize y coordinate to top-left of main display.
+ }
else
- mousePoint = NSMakePoint(mousePoint.x, view.bounds.size.height - mousePoint.y);
+ {
+ mousePoint = event.locationInWindow;
+ if (event.window == nil)
+ mousePoint = [[view window] convertPointFromScreen:mousePoint];
+ mousePoint = [view convertPoint:mousePoint fromView:nil]; // Convert to local coordinates of view
+ if ([view isFlipped])
+ mousePoint = NSMakePoint(mousePoint.x, mousePoint.y);
+ else
+ mousePoint = NSMakePoint(mousePoint.x, view.bounds.size.height - mousePoint.y);
+ }
io.AddMouseSourceEvent(GetMouseSource(event));
io.AddMousePosEvent((float)mousePoint.x, (float)mousePoint.y);
return io.WantCaptureMouse;
@@ -818,6 +862,294 @@
}];
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the back-end to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+struct ImGuiViewportDataOSX
+{
+ NSWindow* Window;
+ bool WindowOwned;
+
+ ImGuiViewportDataOSX() { WindowOwned = false; }
+ ~ImGuiViewportDataOSX() { IM_ASSERT(Window == nil); }
+};
+
+@interface ImGui_ImplOSX_Window: NSWindow
+@end
+
+@implementation ImGui_ImplOSX_Window
+
+- (BOOL)canBecomeKeyWindow
+{
+ return YES;
+}
+
+@end
+
+static void ConvertNSRect(NSRect* r)
+{
+ NSRect firstScreenFrame = NSScreen.screens[0].frame;
+ IM_ASSERT(firstScreenFrame.origin.x == 0 && firstScreenFrame.origin.y == 0);
+ r->origin.y = firstScreenFrame.size.height - r->origin.y - r->size.height;
+}
+
+static void ImGui_ImplOSX_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplOSX_Data* bd = ImGui_ImplOSX_GetBackendData();
+ ImGuiViewportDataOSX* data = IM_NEW(ImGuiViewportDataOSX)();
+ viewport->PlatformUserData = data;
+
+ NSScreen* screen = bd->Window.screen;
+ NSRect rect = NSMakeRect(viewport->Pos.x, viewport->Pos.y, viewport->Size.x, viewport->Size.y);
+ ConvertNSRect(&rect);
+
+ NSWindowStyleMask styleMask = 0;
+ if (viewport->Flags & ImGuiViewportFlags_NoDecoration)
+ styleMask |= NSWindowStyleMaskBorderless;
+ else
+ styleMask |= NSWindowStyleMaskTitled | NSWindowStyleMaskResizable | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
+
+ NSWindow* window = [[ImGui_ImplOSX_Window alloc] initWithContentRect:rect
+ styleMask:styleMask
+ backing:NSBackingStoreBuffered
+ defer:YES
+ screen:screen];
+ if (viewport->Flags & ImGuiViewportFlags_TopMost)
+ [window setLevel:NSFloatingWindowLevel];
+
+ window.title = @"Untitled";
+ window.opaque = YES;
+
+ KeyEventResponder* view = [[KeyEventResponder alloc] initWithFrame:rect];
+ if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6 && ceil(NSAppKitVersionNumber) < NSAppKitVersionNumber10_15)
+ [view setWantsBestResolutionOpenGLSurface:YES];
+
+ window.contentView = view;
+
+ data->Window = window;
+ data->WindowOwned = true;
+ viewport->PlatformRequestResize = false;
+ viewport->PlatformHandle = viewport->PlatformHandleRaw = (__bridge_retained void*)window;
+}
+
+static void ImGui_ImplOSX_DestroyWindow(ImGuiViewport* viewport)
+{
+ NSWindow* window = (__bridge_transfer NSWindow*)viewport->PlatformHandleRaw;
+ window = nil;
+
+ if (ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData)
+ {
+ NSWindow* window = data->Window;
+ if (window != nil && data->WindowOwned)
+ {
+ window.contentView = nil;
+ window.contentViewController = nil;
+ [window orderOut:nil];
+ }
+ data->Window = nil;
+ IM_DELETE(data);
+ }
+ viewport->PlatformUserData = viewport->PlatformHandle = viewport->PlatformHandleRaw = nullptr;
+}
+
+static void ImGui_ImplOSX_ShowWindow(ImGuiViewport* viewport)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
+ [data->Window orderFront:nil];
+ else
+ [data->Window makeKeyAndOrderFront:nil];
+
+ [data->Window setIsVisible:YES];
+}
+
+static ImVec2 ImGui_ImplOSX_GetWindowPos(ImGuiViewport* viewport)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ NSWindow* window = data->Window;
+ NSRect frame = window.frame;
+ NSRect contentRect = window.contentLayoutRect;
+ if (window.styleMask & NSWindowStyleMaskFullSizeContentView) // No title bar windows should be considered.
+ contentRect = frame;
+
+ NSRect firstScreenFrame = NSScreen.screens[0].frame;
+ return ImVec2(frame.origin.x, firstScreenFrame.size.height - frame.origin.y - contentRect.size.height);
+}
+
+static void ImGui_ImplOSX_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ NSWindow* window = data->Window;
+ NSSize size = window.frame.size;
+
+ NSRect r = NSMakeRect(pos.x, pos.y, size.width, size.height);
+ ConvertNSRect(&r);
+ [window setFrameOrigin:r.origin];
+}
+
+static ImVec2 ImGui_ImplOSX_GetWindowSize(ImGuiViewport* viewport)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ NSWindow* window = data->Window;
+ NSSize size = window.contentLayoutRect.size;
+ return ImVec2(size.width, size.height);
+}
+
+static void ImGui_ImplOSX_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ NSWindow* window = data->Window;
+ NSRect rect = window.frame;
+ rect.origin.y -= (size.y - rect.size.height);
+ rect.size.width = size.x;
+ rect.size.height = size.y;
+ [window setFrame:rect display:YES];
+}
+
+static void ImGui_ImplOSX_SetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplOSX_Data* bd = ImGui_ImplOSX_GetBackendData();
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+ [data->Window makeKeyAndOrderFront:bd->Window];
+}
+
+static bool ImGui_ImplOSX_GetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ return data->Window.isKeyWindow;
+}
+
+static bool ImGui_ImplOSX_GetWindowMinimized(ImGuiViewport* viewport)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ return data->Window.isMiniaturized;
+}
+
+static void ImGui_ImplOSX_SetWindowTitle(ImGuiViewport* viewport, const char* title)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ data->Window.title = [NSString stringWithUTF8String:title];
+}
+
+static void ImGui_ImplOSX_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+ IM_ASSERT(alpha >= 0.0f && alpha <= 1.0f);
+
+ data->Window.alphaValue = alpha;
+}
+
+static float ImGui_ImplOSX_GetWindowDpiScale(ImGuiViewport* viewport)
+{
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)viewport->PlatformUserData;
+ IM_ASSERT(data->Window != 0);
+
+ return data->Window.backingScaleFactor;
+}
+
+static void ImGui_ImplOSX_UpdateMonitors()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Monitors.resize(0);
+
+ NSRect firstScreenFrame = NSScreen.screens[0].frame;
+ IM_ASSERT(firstScreenFrame.origin.x == 0 && firstScreenFrame.origin.y == 0);
+
+ for (NSScreen* screen in NSScreen.screens)
+ {
+ NSRect frame = screen.frame;
+ NSRect visibleFrame = screen.visibleFrame;
+ ConvertNSRect(&frame);
+ ConvertNSRect(&visibleFrame);
+
+ ImGuiPlatformMonitor imgui_monitor;
+ imgui_monitor.MainPos = ImVec2(frame.origin.x, frame.origin.y);
+ imgui_monitor.MainSize = ImVec2(frame.size.width, frame.size.height);
+ imgui_monitor.WorkPos = ImVec2(visibleFrame.origin.x, visibleFrame.origin.y);
+ imgui_monitor.WorkSize = ImVec2(visibleFrame.size.width, visibleFrame.size.height);
+ imgui_monitor.DpiScale = screen.backingScaleFactor;
+ imgui_monitor.PlatformHandle = (__bridge_retained void*)screen;
+
+ platform_io.Monitors.push_back(imgui_monitor);
+ }
+}
+
+static void ImGui_ImplOSX_InitPlatformInterface()
+{
+ ImGui_ImplOSX_Data* bd = ImGui_ImplOSX_GetBackendData();
+
+ // Register platform interface (will be coupled with a renderer interface)
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Platform_CreateWindow = ImGui_ImplOSX_CreateWindow;
+ platform_io.Platform_DestroyWindow = ImGui_ImplOSX_DestroyWindow;
+ platform_io.Platform_ShowWindow = ImGui_ImplOSX_ShowWindow;
+ platform_io.Platform_SetWindowPos = ImGui_ImplOSX_SetWindowPos;
+ platform_io.Platform_GetWindowPos = ImGui_ImplOSX_GetWindowPos;
+ platform_io.Platform_SetWindowSize = ImGui_ImplOSX_SetWindowSize;
+ platform_io.Platform_GetWindowSize = ImGui_ImplOSX_GetWindowSize;
+ platform_io.Platform_SetWindowFocus = ImGui_ImplOSX_SetWindowFocus;
+ platform_io.Platform_GetWindowFocus = ImGui_ImplOSX_GetWindowFocus;
+ platform_io.Platform_GetWindowMinimized = ImGui_ImplOSX_GetWindowMinimized;
+ platform_io.Platform_SetWindowTitle = ImGui_ImplOSX_SetWindowTitle;
+ platform_io.Platform_SetWindowAlpha = ImGui_ImplOSX_SetWindowAlpha;
+ platform_io.Platform_GetWindowDpiScale = ImGui_ImplOSX_GetWindowDpiScale; // FIXME-DPI
+
+ // Register main window handle (which is owned by the main application, not by us)
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGuiViewportDataOSX* data = IM_NEW(ImGuiViewportDataOSX)();
+ data->Window = bd->Window;
+ data->WindowOwned = false;
+ main_viewport->PlatformUserData = data;
+ main_viewport->PlatformHandle = (__bridge void*)bd->Window;
+
+ [NSNotificationCenter.defaultCenter addObserver:bd->Observer
+ selector:@selector(displaysDidChange:)
+ name:NSApplicationDidChangeScreenParametersNotification
+ object:nil];
+}
+
+static void ImGui_ImplOSX_ShutdownPlatformInterface()
+{
+ ImGui_ImplOSX_Data* bd = ImGui_ImplOSX_GetBackendData();
+ [NSNotificationCenter.defaultCenter removeObserver:bd->Observer
+ name:NSApplicationDidChangeScreenParametersNotification
+ object:nil];
+ bd->Observer = nullptr;
+ bd->Window = nullptr;
+ if (bd->Monitor != nullptr)
+ {
+ [NSEvent removeMonitor:bd->Monitor];
+ bd->Monitor = nullptr;
+ }
+
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGuiViewportDataOSX* data = (ImGuiViewportDataOSX*)main_viewport->PlatformUserData;
+ IM_DELETE(data);
+ main_viewport->PlatformUserData = nullptr;
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#endif // #ifndef IMGUI_DISABLE
diff --git a/backends/imgui_impl_sdl2.cpp b/backends/imgui_impl_sdl2.cpp
index b1cc8c9..62c0cbf 100644
--- a/backends/imgui_impl_sdl2.cpp
+++ b/backends/imgui_impl_sdl2.cpp
@@ -9,7 +9,11 @@
// [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]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
-// [X] Platform: Basic IME support. App needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
+// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+// Issues:
+// [ ] Platform: Multi-viewport: Minimized windows seems to break mouse wheel events (at least under Windows).
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
+// [x] Platform: Basic IME support. App needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -21,6 +25,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-08-22: moved some OS/backend related function pointers from ImGuiIO to ImGuiPlatformIO:
// - io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn
// - io.SetClipboardTextFn -> platform_io.Platform_SetClipboardTextFn
@@ -56,7 +61,7 @@
// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
// 2021-08-17: Calling io.AddFocusEvent() on SDL_WINDOWEVENT_FOCUS_GAINED/SDL_WINDOWEVENT_FOCUS_LOST.
// 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+)
-// 2021-06-29: *BREAKING CHANGE* Removed 'SDL_Window* window' parameter to ImGui_ImplSDL2_NewFrame() which was unnecessary.
+// 2021-06:29: *BREAKING CHANGE* Removed 'SDL_Window* window' parameter to ImGui_ImplSDL2_NewFrame() which was unnecessary.
// 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).
// 2021-03-22: Rework global mouse pos availability check listing supported platforms explicitly, effectively fixing mouse access on Raspberry Pi. (#2837, #3950)
// 2020-05-25: Misc: Report a zero display-size when window is minimized, to be consistent with other backends.
@@ -97,6 +102,7 @@
#endif
// SDL
+// (the multi-viewports feature requires SDL features supported from SDL 2.0.4+. SDL 2.0.5+ is highly recommended)
#include <SDL.h>
#include <SDL_syswm.h>
#ifdef __APPLE__
@@ -111,7 +117,16 @@
#else
#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE 0
#endif
+#define SDL_HAS_WINDOW_ALPHA SDL_VERSION_ATLEAST(2,0,5)
+#define SDL_HAS_ALWAYS_ON_TOP SDL_VERSION_ATLEAST(2,0,5)
+#define SDL_HAS_USABLE_DISPLAY_BOUNDS SDL_VERSION_ATLEAST(2,0,5)
+#define SDL_HAS_PER_MONITOR_DPI SDL_VERSION_ATLEAST(2,0,4)
#define SDL_HAS_VULKAN SDL_VERSION_ATLEAST(2,0,6)
+#define SDL_HAS_DISPLAY_EVENT SDL_VERSION_ATLEAST(2,0,9)
+#define SDL_HAS_SHOW_WINDOW_ACTIVATION_HINT SDL_VERSION_ATLEAST(2,0,18)
+#if !SDL_HAS_VULKAN
+static const Uint32 SDL_WINDOW_VULKAN = 0x10000000;
+#endif
// SDL Data
struct ImGui_ImplSDL2_Data
@@ -121,6 +136,8 @@
SDL_Renderer* Renderer;
Uint64 Time;
char* ClipboardTextData;
+ bool UseVulkan;
+ bool WantUpdateMonitors;
// Mouse handling
Uint32 MouseWindowID;
@@ -129,6 +146,7 @@
SDL_Cursor* MouseLastCursor;
int MouseLastLeaveFrame;
bool MouseCanUseGlobalState;
+ bool MouseCanReportHoveredViewport; // This is hard to use/unreliable on SDL so we'll set ImGuiBackendFlags_HasMouseHoveredViewport dynamically based on state.
// Gamepad handling
ImVector<SDL_GameController*> Gamepads;
@@ -147,6 +165,11 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplSDL2_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplSDL2_UpdateMonitors();
+static void ImGui_ImplSDL2_InitPlatformInterface(SDL_Window* window, void* sdl_gl_context);
+static void ImGui_ImplSDL2_ShutdownPlatformInterface();
+
// Functions
static const char* ImGui_ImplSDL2_GetClipboardText(ImGuiContext*)
{
@@ -163,13 +186,13 @@
}
// Note: native IME will only display if user calls SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1") _before_ SDL_CreateWindow().
-static void ImGui_ImplSDL2_PlatformSetImeData(ImGuiContext*, ImGuiViewport*, ImGuiPlatformImeData* data)
+static void ImGui_ImplSDL2_PlatformSetImeData(ImGuiContext*, ImGuiViewport* viewport, ImGuiPlatformImeData* data)
{
if (data->WantVisible)
{
SDL_Rect r;
- r.x = (int)data->InputPos.x;
- r.y = (int)data->InputPos.y;
+ r.x = (int)(data->InputPos.x - viewport->Pos.x);
+ r.y = (int)(data->InputPos.y - viewport->Pos.y + data->InputLineHeight);
r.w = 1;
r.h = (int)data->InputLineHeight;
SDL_SetTextInputRect(&r);
@@ -316,15 +339,13 @@
static ImGuiViewport* ImGui_ImplSDL2_GetViewportForWindowID(Uint32 window_id)
{
- ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
- return (window_id == bd->WindowID) ? ImGui::GetMainViewport() : NULL;
+ return ImGui::FindViewportByPlatformHandle((void*)(intptr_t)window_id);
}
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
-// 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.
bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event)
{
ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
@@ -338,6 +359,13 @@
if (ImGui_ImplSDL2_GetViewportForWindowID(event->motion.windowID) == NULL)
return false;
ImVec2 mouse_pos((float)event->motion.x, (float)event->motion.y);
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ int window_x, window_y;
+ SDL_GetWindowPosition(SDL_GetWindowFromID(event->motion.windowID), &window_x, &window_y);
+ mouse_pos.x += window_x;
+ mouse_pos.y += window_y;
+ }
io.AddMouseSourceEvent(event->motion.which == SDL_TOUCH_MOUSEID ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse);
io.AddMousePosEvent(mouse_pos.x, mouse_pos.y);
return true;
@@ -397,10 +425,21 @@
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.
return true;
}
+#if SDL_HAS_DISPLAY_EVENT
+ case SDL_DISPLAYEVENT:
+ {
+ // 2.0.26 has SDL_DISPLAYEVENT_CONNECTED/SDL_DISPLAYEVENT_DISCONNECTED/SDL_DISPLAYEVENT_ORIENTATION,
+ // so change of DPI/Scaling are not reflected in this event. (SDL3 has it)
+ bd->WantUpdateMonitors = true;
+ return true;
+ }
+#endif
case SDL_WINDOWEVENT:
{
- if (ImGui_ImplSDL2_GetViewportForWindowID(event->window.windowID) == NULL)
+ ImGuiViewport* viewport = ImGui_ImplSDL2_GetViewportForWindowID(event->window.windowID);
+ if (viewport == NULL)
return false;
+
// - 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.
// - However we won't get a correct LEAVE event for a captured window.
// - In some cases, when detaching a window from main viewport SDL may send SDL_WINDOWEVENT_ENTER one frame too late,
@@ -416,8 +455,14 @@
bd->MouseLastLeaveFrame = ImGui::GetFrameCount() + 1;
if (window_event == SDL_WINDOWEVENT_FOCUS_GAINED)
io.AddFocusEvent(true);
- else if (event->window.event == SDL_WINDOWEVENT_FOCUS_LOST)
+ else if (window_event == SDL_WINDOWEVENT_FOCUS_LOST)
io.AddFocusEvent(false);
+ else if (window_event == SDL_WINDOWEVENT_CLOSE)
+ viewport->PlatformRequestClose = true;
+ else if (window_event == SDL_WINDOWEVENT_MOVED)
+ viewport->PlatformRequestMove = true;
+ else if (window_event == SDL_WINDOWEVENT_RESIZED)
+ viewport->PlatformRequestResize = true;
return true;
}
case SDL_CONTROLLERDEVICEADDED:
@@ -455,13 +500,24 @@
ImGui_ImplSDL2_Data* bd = IM_NEW(ImGui_ImplSDL2_Data)();
io.BackendPlatformUserData = (void*)bd;
io.BackendPlatformName = "imgui_impl_sdl2";
- io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
- io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
+ io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
+ io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
+ if (mouse_can_use_global_state)
+ io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
bd->Window = window;
bd->WindowID = SDL_GetWindowID(window);
bd->Renderer = renderer;
+
+ // SDL on Linux/OSX doesn't report events for unfocused windows (see https://github.com/ocornut/imgui/issues/4960)
+ // We will use 'MouseCanReportHoveredViewport' to set 'ImGuiBackendFlags_HasMouseHoveredViewport' dynamically each frame.
bd->MouseCanUseGlobalState = mouse_can_use_global_state;
+#ifndef __APPLE__
+ bd->MouseCanReportHoveredViewport = bd->MouseCanUseGlobalState;
+#else
+ bd->MouseCanReportHoveredViewport = false;
+#endif
+ bd->WantUpdateMonitors = true;
ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
platform_io.Platform_SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText;
@@ -524,7 +580,11 @@
SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0");
#endif
- (void)sdl_gl_context; // Unused in 'master' branch.
+ // We need SDL_CaptureMouse(), SDL_GetGlobalMouseState() from SDL 2.0.4+ to support multiple viewports.
+ // We left the call to ImGui_ImplSDL2_InitPlatformInterface() outside of #ifdef to avoid unused-function warnings.
+ if ((io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) && (io.BackendFlags & ImGuiBackendFlags_PlatformHasViewports))
+ ImGui_ImplSDL2_InitPlatformInterface(window, sdl_gl_context);
+
return true;
}
@@ -538,7 +598,11 @@
#if !SDL_HAS_VULKAN
IM_ASSERT(0 && "Unsupported");
#endif
- return ImGui_ImplSDL2_Init(window, nullptr, nullptr);
+ if (!ImGui_ImplSDL2_Init(window, nullptr, nullptr))
+ return false;
+ ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+ bd->UseVulkan = true;
+ return true;
}
bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window)
@@ -572,6 +636,8 @@
IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplSDL2_ShutdownPlatformInterface();
+
if (bd->ClipboardTextData)
SDL_free(bd->ClipboardTextData);
for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
@@ -580,10 +646,11 @@
io.BackendPlatformName = nullptr;
io.BackendPlatformUserData = nullptr;
- io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad);
+ io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_HasMouseHoveredViewport);
IM_DELETE(bd);
}
+// This code is incredibly messy because some of the functions we need for full viewport support are not available in SDL < 2.0.4.
static void ImGui_ImplSDL2_UpdateMouseData()
{
ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
@@ -594,25 +661,56 @@
// 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
SDL_CaptureMouse((bd->MouseButtonsDown != 0) ? SDL_TRUE : SDL_FALSE);
SDL_Window* focused_window = SDL_GetKeyboardFocus();
- const bool is_app_focused = (bd->Window == focused_window);
+ const bool is_app_focused = (focused_window && (bd->Window == focused_window || ImGui_ImplSDL2_GetViewportForWindowID(SDL_GetWindowID(focused_window)) != NULL));
#else
+ SDL_Window* focused_window = bd->Window;
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
#endif
+
if (is_app_focused)
{
// (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if (io.WantSetMousePos)
- SDL_WarpMouseInWindow(bd->Window, (int)io.MousePos.x, (int)io.MousePos.y);
+ {
+#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ SDL_WarpMouseGlobal((int)io.MousePos.x, (int)io.MousePos.y);
+ else
+#endif
+ SDL_WarpMouseInWindow(bd->Window, (int)io.MousePos.x, (int)io.MousePos.y);
+ }
// (Optional) Fallback to provide mouse position when focused (SDL_MOUSEMOTION already provides this when hovered or captured)
if (bd->MouseCanUseGlobalState && bd->MouseButtonsDown == 0)
{
- int window_x, window_y, mouse_x_global, mouse_y_global;
- SDL_GetGlobalMouseState(&mouse_x_global, &mouse_y_global);
- SDL_GetWindowPosition(bd->Window, &window_x, &window_y);
- io.AddMousePosEvent((float)(mouse_x_global - window_x), (float)(mouse_y_global - window_y));
+ // 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 mouse_x, mouse_y, window_x, window_y;
+ SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
+ if (!(io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable))
+ {
+ SDL_GetWindowPosition(focused_window, &window_x, &window_y);
+ mouse_x -= window_x;
+ mouse_y -= window_y;
+ }
+ io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
}
}
+
+ // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
+ // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
+ // - [!] SDL backend does NOT correctly ignore viewports with the _NoInputs flag.
+ // 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] 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).
+ if (io.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
+ {
+ ImGuiID mouse_viewport_id = 0;
+ if (ImGuiViewport* mouse_viewport = ImGui_ImplSDL2_GetViewportForWindowID(bd->MouseWindowID))
+ mouse_viewport_id = mouse_viewport->ID;
+ io.AddMouseViewportEvent(mouse_viewport_id);
+ }
}
static void ImGui_ImplSDL2_UpdateMouseCursor()
@@ -746,6 +844,43 @@
ImGui_ImplSDL2_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadRStickDown, SDL_CONTROLLER_AXIS_RIGHTY, +thumb_dead_zone, +32767);
}
+// FIXME: Note that doesn't update with DPI/Scaling change only as SDL2 doesn't have an event for it (SDL3 has).
+static void ImGui_ImplSDL2_UpdateMonitors()
+{
+ ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Monitors.resize(0);
+ bd->WantUpdateMonitors = false;
+ int display_count = SDL_GetNumVideoDisplays();
+ for (int n = 0; n < display_count; n++)
+ {
+ // 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.
+ ImGuiPlatformMonitor monitor;
+ SDL_Rect r;
+ SDL_GetDisplayBounds(n, &r);
+ monitor.MainPos = monitor.WorkPos = ImVec2((float)r.x, (float)r.y);
+ monitor.MainSize = monitor.WorkSize = ImVec2((float)r.w, (float)r.h);
+#if SDL_HAS_USABLE_DISPLAY_BOUNDS
+ SDL_GetDisplayUsableBounds(n, &r);
+ monitor.WorkPos = ImVec2((float)r.x, (float)r.y);
+ monitor.WorkSize = ImVec2((float)r.w, (float)r.h);
+#endif
+#if SDL_HAS_PER_MONITOR_DPI
+ // FIXME-VIEWPORT: On MacOS SDL reports actual monitor DPI scale, ignoring OS configuration. We may want to set
+ // DpiScale to cocoa_window.backingScaleFactor here.
+ float dpi = 0.0f;
+ if (!SDL_GetDisplayDPI(n, &dpi, nullptr, nullptr))
+ {
+ if (dpi <= 0.0f)
+ continue; // Some accessibility applications are declaring virtual monitors with a DPI of 0, see #7902.
+ monitor.DpiScale = dpi / 96.0f;
+ }
+#endif
+ monitor.PlatformHandle = (void*)(intptr_t)n;
+ platform_io.Monitors.push_back(monitor);
+ }
+}
+
void ImGui_ImplSDL2_NewFrame()
{
ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
@@ -766,6 +901,10 @@
if (w > 0 && h > 0)
io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
+ // Update monitors
+ if (bd->WantUpdateMonitors)
+ ImGui_ImplSDL2_UpdateMonitors();
+
// Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
// (Accept SDL_GetPerformanceCounter() not returning a monotonically increasing value. Happens in VMs and Emscripten, see #6189, #6114, #3644)
static Uint64 frequency = SDL_GetPerformanceFrequency();
@@ -782,6 +921,13 @@
io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
}
+ // Our io.AddMouseViewportEvent() calls will only be valid when not capturing.
+ // Technically speaking testing for 'bd->MouseButtonsDown == 0' would be more rigorous, but testing for payload reduces noise and potential side-effects.
+ if (bd->MouseCanReportHoveredViewport && ImGui::GetDragDropPayload() == nullptr)
+ io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport;
+ else
+ io.BackendFlags &= ~ImGuiBackendFlags_HasMouseHoveredViewport;
+
ImGui_ImplSDL2_UpdateMouseData();
ImGui_ImplSDL2_UpdateMouseCursor();
@@ -789,6 +935,256 @@
ImGui_ImplSDL2_UpdateGamepads();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplSDL2_ViewportData
+{
+ SDL_Window* Window;
+ Uint32 WindowID;
+ bool WindowOwned;
+ SDL_GLContext GLContext;
+
+ ImGui_ImplSDL2_ViewportData() { Window = nullptr; WindowID = 0; WindowOwned = false; GLContext = nullptr; }
+ ~ImGui_ImplSDL2_ViewportData() { IM_ASSERT(Window == nullptr && GLContext == nullptr); }
+};
+
+static void ImGui_ImplSDL2_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+ ImGui_ImplSDL2_ViewportData* vd = IM_NEW(ImGui_ImplSDL2_ViewportData)();
+ viewport->PlatformUserData = vd;
+
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGui_ImplSDL2_ViewportData* main_viewport_data = (ImGui_ImplSDL2_ViewportData*)main_viewport->PlatformUserData;
+
+ // Share GL resources with main context
+ bool use_opengl = (main_viewport_data->GLContext != nullptr);
+ SDL_GLContext backup_context = nullptr;
+ if (use_opengl)
+ {
+ backup_context = SDL_GL_GetCurrentContext();
+ SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
+ SDL_GL_MakeCurrent(main_viewport_data->Window, main_viewport_data->GLContext);
+ }
+
+ Uint32 sdl_flags = 0;
+ sdl_flags |= use_opengl ? SDL_WINDOW_OPENGL : (bd->UseVulkan ? SDL_WINDOW_VULKAN : 0);
+ sdl_flags |= SDL_GetWindowFlags(bd->Window) & SDL_WINDOW_ALLOW_HIGHDPI;
+ sdl_flags |= SDL_WINDOW_HIDDEN;
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? SDL_WINDOW_BORDERLESS : 0;
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? 0 : SDL_WINDOW_RESIZABLE;
+#if !defined(_WIN32)
+ // See SDL hack in ImGui_ImplSDL2_ShowWindow().
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon) ? SDL_WINDOW_SKIP_TASKBAR : 0;
+#endif
+#if SDL_HAS_ALWAYS_ON_TOP
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_TopMost) ? SDL_WINDOW_ALWAYS_ON_TOP : 0;
+#endif
+ 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);
+ vd->WindowOwned = true;
+ if (use_opengl)
+ {
+ vd->GLContext = SDL_GL_CreateContext(vd->Window);
+ SDL_GL_SetSwapInterval(0);
+ }
+ if (use_opengl && backup_context)
+ SDL_GL_MakeCurrent(vd->Window, backup_context);
+
+ viewport->PlatformHandle = (void*)(intptr_t)SDL_GetWindowID(vd->Window);
+ viewport->PlatformHandleRaw = nullptr;
+ SDL_SysWMinfo info;
+ SDL_VERSION(&info.version);
+ if (SDL_GetWindowWMInfo(vd->Window, &info))
+ {
+#if defined(SDL_VIDEO_DRIVER_WINDOWS)
+ viewport->PlatformHandleRaw = info.info.win.window;
+#elif defined(__APPLE__) && defined(SDL_VIDEO_DRIVER_COCOA)
+ viewport->PlatformHandleRaw = (void*)info.info.cocoa.window;
+#endif
+ }
+}
+
+static void ImGui_ImplSDL2_DestroyWindow(ImGuiViewport* viewport)
+{
+ if (ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData)
+ {
+ if (vd->GLContext && vd->WindowOwned)
+ SDL_GL_DeleteContext(vd->GLContext);
+ if (vd->Window && vd->WindowOwned)
+ SDL_DestroyWindow(vd->Window);
+ vd->GLContext = nullptr;
+ vd->Window = nullptr;
+ IM_DELETE(vd);
+ }
+ viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
+}
+
+static void ImGui_ImplSDL2_ShowWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+#if defined(_WIN32)
+ HWND hwnd = (HWND)viewport->PlatformHandleRaw;
+
+ // SDL hack: Hide icon from task bar
+ // 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.
+ if (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon)
+ {
+ LONG ex_style = ::GetWindowLong(hwnd, GWL_EXSTYLE);
+ ex_style &= ~WS_EX_APPWINDOW;
+ ex_style |= WS_EX_TOOLWINDOW;
+ ::SetWindowLong(hwnd, GWL_EXSTYLE, ex_style);
+ }
+#endif
+
+#if SDL_HAS_SHOW_WINDOW_ACTIVATION_HINT
+ SDL_SetHint(SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN, (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing) ? "1" : "0");
+#elif defined(_WIN32)
+ // SDL hack: SDL always activate/focus windows :/
+ if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
+ {
+ ::ShowWindow(hwnd, SW_SHOWNA);
+ return;
+ }
+#endif
+ SDL_ShowWindow(vd->Window);
+}
+
+static ImVec2 ImGui_ImplSDL2_GetWindowPos(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ int x = 0, y = 0;
+ SDL_GetWindowPosition(vd->Window, &x, &y);
+ return ImVec2((float)x, (float)y);
+}
+
+static void ImGui_ImplSDL2_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowPosition(vd->Window, (int)pos.x, (int)pos.y);
+}
+
+static ImVec2 ImGui_ImplSDL2_GetWindowSize(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ int w = 0, h = 0;
+ SDL_GetWindowSize(vd->Window, &w, &h);
+ return ImVec2((float)w, (float)h);
+}
+
+static void ImGui_ImplSDL2_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowSize(vd->Window, (int)size.x, (int)size.y);
+}
+
+static void ImGui_ImplSDL2_SetWindowTitle(ImGuiViewport* viewport, const char* title)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowTitle(vd->Window, title);
+}
+
+#if SDL_HAS_WINDOW_ALPHA
+static void ImGui_ImplSDL2_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowOpacity(vd->Window, alpha);
+}
+#endif
+
+static void ImGui_ImplSDL2_SetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ SDL_RaiseWindow(vd->Window);
+}
+
+static bool ImGui_ImplSDL2_GetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_INPUT_FOCUS) != 0;
+}
+
+static bool ImGui_ImplSDL2_GetWindowMinimized(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_MINIMIZED) != 0;
+}
+
+static void ImGui_ImplSDL2_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ if (vd->GLContext)
+ SDL_GL_MakeCurrent(vd->Window, vd->GLContext);
+}
+
+static void ImGui_ImplSDL2_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ if (vd->GLContext)
+ {
+ SDL_GL_MakeCurrent(vd->Window, vd->GLContext);
+ SDL_GL_SwapWindow(vd->Window);
+ }
+}
+
+// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
+// SDL is graceful enough to _not_ need <vulkan/vulkan.h> so we can safely include this.
+#if SDL_HAS_VULKAN
+#include <SDL_vulkan.h>
+static int ImGui_ImplSDL2_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface)
+{
+ ImGui_ImplSDL2_ViewportData* vd = (ImGui_ImplSDL2_ViewportData*)viewport->PlatformUserData;
+ (void)vk_allocator;
+ SDL_bool ret = SDL_Vulkan_CreateSurface(vd->Window, (VkInstance)vk_instance, (VkSurfaceKHR*)out_vk_surface);
+ return ret ? 0 : 1; // ret ? VK_SUCCESS : VK_NOT_READY
+}
+#endif // SDL_HAS_VULKAN
+
+static void ImGui_ImplSDL2_InitPlatformInterface(SDL_Window* window, void* sdl_gl_context)
+{
+ // Register platform interface (will be coupled with a renderer interface)
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Platform_CreateWindow = ImGui_ImplSDL2_CreateWindow;
+ platform_io.Platform_DestroyWindow = ImGui_ImplSDL2_DestroyWindow;
+ platform_io.Platform_ShowWindow = ImGui_ImplSDL2_ShowWindow;
+ platform_io.Platform_SetWindowPos = ImGui_ImplSDL2_SetWindowPos;
+ platform_io.Platform_GetWindowPos = ImGui_ImplSDL2_GetWindowPos;
+ platform_io.Platform_SetWindowSize = ImGui_ImplSDL2_SetWindowSize;
+ platform_io.Platform_GetWindowSize = ImGui_ImplSDL2_GetWindowSize;
+ platform_io.Platform_SetWindowFocus = ImGui_ImplSDL2_SetWindowFocus;
+ platform_io.Platform_GetWindowFocus = ImGui_ImplSDL2_GetWindowFocus;
+ platform_io.Platform_GetWindowMinimized = ImGui_ImplSDL2_GetWindowMinimized;
+ platform_io.Platform_SetWindowTitle = ImGui_ImplSDL2_SetWindowTitle;
+ platform_io.Platform_RenderWindow = ImGui_ImplSDL2_RenderWindow;
+ platform_io.Platform_SwapBuffers = ImGui_ImplSDL2_SwapBuffers;
+#if SDL_HAS_WINDOW_ALPHA
+ platform_io.Platform_SetWindowAlpha = ImGui_ImplSDL2_SetWindowAlpha;
+#endif
+#if SDL_HAS_VULKAN
+ platform_io.Platform_CreateVkSurface = ImGui_ImplSDL2_CreateVkSurface;
+#endif
+
+ // Register main window handle (which is owned by the main application, not by us)
+ // 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.
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGui_ImplSDL2_ViewportData* vd = IM_NEW(ImGui_ImplSDL2_ViewportData)();
+ vd->Window = window;
+ vd->WindowID = SDL_GetWindowID(window);
+ vd->WindowOwned = false;
+ vd->GLContext = sdl_gl_context;
+ main_viewport->PlatformUserData = vd;
+ main_viewport->PlatformHandle = (void*)(intptr_t)vd->WindowID;
+}
+
+static void ImGui_ImplSDL2_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#if defined(__clang__)
diff --git a/backends/imgui_impl_sdl2.h b/backends/imgui_impl_sdl2.h
index e551e52..78c76a8 100644
--- a/backends/imgui_impl_sdl2.h
+++ b/backends/imgui_impl_sdl2.h
@@ -8,7 +8,11 @@
// [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]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
-// [X] Platform: Basic IME support. App needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
+// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+// Issues:
+// [ ] Platform: Multi-viewport: Minimized windows seems to break mouse wheel events (at least under Windows).
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
+// [x] Platform: Basic IME support. App needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_sdl3.cpp b/backends/imgui_impl_sdl3.cpp
index 540b693..f2710c5 100644
--- a/backends/imgui_impl_sdl3.cpp
+++ b/backends/imgui_impl_sdl3.cpp
@@ -10,6 +10,10 @@
// [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]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+// [x] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable' -> the OS animation effect when window gets created/destroyed is problematic. SDL2 backend doesn't have issue.
+// Issues:
+// [ ] Platform: Multi-viewport: Minimized windows seems to break mouse wheel events (at least under Windows).
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -21,6 +25,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-09-03: Update for SDL3 api changes: SDL_GetGamepads() memory ownership revert. (#7918, #7898, #7807)
// 2024-08-22: moved some OS/backend related function pointers from ImGuiIO to ImGuiPlatformIO:
// - io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn
@@ -91,6 +96,8 @@
SDL_Renderer* Renderer;
Uint64 Time;
char* ClipboardTextData;
+ bool UseVulkan;
+ bool WantUpdateMonitors;
// IME handling
SDL_Window* ImeWindow;
@@ -102,11 +109,12 @@
SDL_Cursor* MouseLastCursor;
int MousePendingLeaveFrame;
bool MouseCanUseGlobalState;
+ bool MouseCanReportHoveredViewport; // This is hard to use/unreliable on SDL so we'll set ImGuiBackendFlags_HasMouseHoveredViewport dynamically based on state.
// Gamepad handling
- ImVector<SDL_Gamepad*> Gamepads;
+ ImVector<SDL_Gamepad*> Gamepads;
ImGui_ImplSDL3_GamepadMode GamepadMode;
- bool WantUpdateGamepadsList;
+ bool WantUpdateGamepadsList;
ImGui_ImplSDL3_Data() { memset((void*)this, 0, sizeof(*this)); }
};
@@ -120,6 +128,11 @@
return ImGui::GetCurrentContext() ? (ImGui_ImplSDL3_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
}
+// Forward Declarations
+static void ImGui_ImplSDL3_UpdateMonitors();
+static void ImGui_ImplSDL3_InitPlatformInterface(SDL_Window* window, void* sdl_gl_context);
+static void ImGui_ImplSDL3_ShutdownPlatformInterface();
+
// Functions
static const char* ImGui_ImplSDL3_GetClipboardText(ImGuiContext*)
{
@@ -149,8 +162,8 @@
if (data->WantVisible)
{
SDL_Rect r;
- r.x = (int)data->InputPos.x;
- r.y = (int)data->InputPos.y;
+ r.x = (int)(data->InputPos.x - viewport->Pos.x);
+ r.y = (int)(data->InputPos.y - viewport->Pos.y + data->InputLineHeight);
r.w = 1;
r.h = (int)data->InputLineHeight;
SDL_SetTextInputArea(window, &r, 0);
@@ -301,18 +314,15 @@
io.AddKeyEvent(ImGuiMod_Super, (sdl_key_mods & SDL_KMOD_GUI) != 0);
}
-
static ImGuiViewport* ImGui_ImplSDL3_GetViewportForWindowID(SDL_WindowID window_id)
{
- ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
- return (window_id == bd->WindowID) ? ImGui::GetMainViewport() : NULL;
+ return ImGui::FindViewportByPlatformHandle((void*)(intptr_t)window_id);
}
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
-// 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.
bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event)
{
ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
@@ -326,6 +336,13 @@
if (ImGui_ImplSDL3_GetViewportForWindowID(event->motion.windowID) == NULL)
return false;
ImVec2 mouse_pos((float)event->motion.x, (float)event->motion.y);
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ int window_x, window_y;
+ SDL_GetWindowPosition(SDL_GetWindowFromID(event->motion.windowID), &window_x, &window_y);
+ mouse_pos.x += window_x;
+ mouse_pos.y += window_y;
+ }
io.AddMouseSourceEvent(event->motion.which == SDL_TOUCH_MOUSEID ? ImGuiMouseSource_TouchScreen : ImGuiMouseSource_Mouse);
io.AddMousePosEvent(mouse_pos.x, mouse_pos.y);
return true;
@@ -381,6 +398,15 @@
io.SetKeyEventNativeData(key, event->key.key, event->key.scancode, event->key.scancode); // To support legacy indexing (<1.87 user code). Legacy backend uses SDLK_*** as indices to IsKeyXXX() functions.
return true;
}
+ case SDL_EVENT_DISPLAY_ORIENTATION:
+ case SDL_EVENT_DISPLAY_ADDED:
+ case SDL_EVENT_DISPLAY_REMOVED:
+ case SDL_EVENT_DISPLAY_MOVED:
+ case SDL_EVENT_DISPLAY_CONTENT_SCALE_CHANGED:
+ {
+ bd->WantUpdateMonitors = true;
+ return true;
+ }
case SDL_EVENT_WINDOW_MOUSE_ENTER:
{
if (ImGui_ImplSDL3_GetViewportForWindowID(event->window.windowID) == NULL)
@@ -408,6 +434,21 @@
io.AddFocusEvent(event->type == SDL_EVENT_WINDOW_FOCUS_GAINED);
return true;
}
+ case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
+ case SDL_EVENT_WINDOW_MOVED:
+ case SDL_EVENT_WINDOW_RESIZED:
+ {
+ ImGuiViewport* viewport = ImGui_ImplSDL3_GetViewportForWindowID(event->window.windowID);
+ if (viewport == NULL)
+ return false;
+ if (event->type == SDL_EVENT_WINDOW_CLOSE_REQUESTED)
+ viewport->PlatformRequestClose = true;
+ if (event->type == SDL_EVENT_WINDOW_MOVED)
+ viewport->PlatformRequestMove = true;
+ if (event->type == SDL_EVENT_WINDOW_RESIZED)
+ viewport->PlatformRequestResize = true;
+ return true;
+ }
case SDL_EVENT_GAMEPAD_ADDED:
case SDL_EVENT_GAMEPAD_REMOVED:
{
@@ -453,11 +494,22 @@
io.BackendPlatformName = "imgui_impl_sdl3";
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
+ if (mouse_can_use_global_state)
+ io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
bd->Window = window;
bd->WindowID = SDL_GetWindowID(window);
bd->Renderer = renderer;
+
+ // SDL on Linux/OSX doesn't report events for unfocused windows (see https://github.com/ocornut/imgui/issues/4960)
+ // We will use 'MouseCanReportHoveredViewport' to set 'ImGuiBackendFlags_HasMouseHoveredViewport' dynamically each frame.
bd->MouseCanUseGlobalState = mouse_can_use_global_state;
+#ifndef __APPLE__
+ bd->MouseCanReportHoveredViewport = bd->MouseCanUseGlobalState;
+#else
+ bd->MouseCanReportHoveredViewport = false;
+#endif
+ bd->WantUpdateMonitors = true;
ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
platform_io.Platform_SetClipboardTextFn = ImGui_ImplSDL3_SetClipboardText;
@@ -489,27 +541,35 @@
// (This is unfortunately a global SDL setting, so enabling it might have a side-effect on your application.
// It is unlikely to make a difference, but if your app absolutely needs to ignore the initial on-focus click:
// you can ignore SDL_EVENT_MOUSE_BUTTON_DOWN events coming right after a SDL_WINDOWEVENT_FOCUS_GAINED)
-#ifdef SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH
SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1");
-#endif
// From 2.0.22: Disable auto-capture, this is preventing drag and drop across multiple windows (see #5710)
-#ifdef SDL_HINT_MOUSE_AUTO_CAPTURE
SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0");
-#endif
+
+ // SDL 3.x : see https://github.com/libsdl-org/SDL/issues/6659
+ SDL_SetHint("SDL_BORDERLESS_WINDOWED_STYLE", "0");
+
+ // We need SDL_CaptureMouse(), SDL_GetGlobalMouseState() from SDL 2.0.4+ to support multiple viewports.
+ // We left the call to ImGui_ImplSDL3_InitPlatformInterface() outside of #ifdef to avoid unused-function warnings.
+ if ((io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) && (io.BackendFlags & ImGuiBackendFlags_PlatformHasViewports))
+ ImGui_ImplSDL3_InitPlatformInterface(window, sdl_gl_context);
return true;
}
+// Should technically be a SDL_GLContext but due to typedef it is sane to keep it void* in public interface.
bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window, void* sdl_gl_context)
{
- IM_UNUSED(sdl_gl_context); // Viewport branch will need this.
return ImGui_ImplSDL3_Init(window, nullptr, sdl_gl_context);
}
bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window)
{
- return ImGui_ImplSDL3_Init(window, nullptr, nullptr);
+ if (!ImGui_ImplSDL3_Init(window, nullptr, nullptr))
+ return false;
+ ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
+ bd->UseVulkan = true;
+ return true;
}
bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window)
@@ -543,6 +603,8 @@
IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplSDL3_ShutdownPlatformInterface();
+
if (bd->ClipboardTextData)
SDL_free(bd->ClipboardTextData);
for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
@@ -551,10 +613,11 @@
io.BackendPlatformName = nullptr;
io.BackendPlatformUserData = nullptr;
- io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad);
+ io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_HasMouseHoveredViewport);
IM_DELETE(bd);
}
+// This code is incredibly messy because some of the functions we need for full viewport support are not available in SDL < 2.0.4.
static void ImGui_ImplSDL3_UpdateMouseData()
{
ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
@@ -565,7 +628,7 @@
// 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
SDL_CaptureMouse((bd->MouseButtonsDown != 0) ? SDL_TRUE : SDL_FALSE);
SDL_Window* focused_window = SDL_GetKeyboardFocus();
- const bool is_app_focused = (bd->Window == focused_window);
+ const bool is_app_focused = (focused_window && (bd->Window == focused_window || ImGui_ImplSDL3_GetViewportForWindowID(SDL_GetWindowID(focused_window)) != NULL));
#else
SDL_Window* focused_window = bd->Window;
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
@@ -574,19 +637,47 @@
{
// (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if (io.WantSetMousePos)
- SDL_WarpMouseInWindow(bd->Window, io.MousePos.x, io.MousePos.y);
+ {
+#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ SDL_WarpMouseGlobal(io.MousePos.x, io.MousePos.y);
+ else
+#endif
+ SDL_WarpMouseInWindow(bd->Window, io.MousePos.x, io.MousePos.y);
+ }
// (Optional) Fallback to provide mouse position when focused (SDL_EVENT_MOUSE_MOTION already provides this when hovered or captured)
if (bd->MouseCanUseGlobalState && bd->MouseButtonsDown == 0)
{
// 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)
- float mouse_x_global, mouse_y_global;
+ // 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)
+ float mouse_x, mouse_y;
int window_x, window_y;
- SDL_GetGlobalMouseState(&mouse_x_global, &mouse_y_global);
- SDL_GetWindowPosition(focused_window, &window_x, &window_y);
- io.AddMousePosEvent(mouse_x_global - window_x, mouse_y_global - window_y);
+ SDL_GetGlobalMouseState(&mouse_x, &mouse_y);
+ if (!(io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable))
+ {
+ SDL_GetWindowPosition(focused_window, &window_x, &window_y);
+ mouse_x -= window_x;
+ mouse_y -= window_y;
+ }
+ io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
}
}
+
+ // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
+ // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
+ // - [!] SDL backend does NOT correctly ignore viewports with the _NoInputs flag.
+ // 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] 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).
+ if (io.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
+ {
+ ImGuiID mouse_viewport_id = 0;
+ if (ImGuiViewport* mouse_viewport = ImGui_ImplSDL3_GetViewportForWindowID(bd->MouseWindowID))
+ mouse_viewport_id = mouse_viewport->ID;
+ io.AddMouseViewportEvent(mouse_viewport_id);
+ }
}
static void ImGui_ImplSDL3_UpdateMouseCursor()
@@ -721,6 +812,38 @@
ImGui_ImplSDL3_UpdateGamepadAnalog(bd, io, ImGuiKey_GamepadRStickDown, SDL_GAMEPAD_AXIS_RIGHTY, +thumb_dead_zone, +32767);
}
+static void ImGui_ImplSDL3_UpdateMonitors()
+{
+ ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Monitors.resize(0);
+ bd->WantUpdateMonitors = false;
+
+ int display_count;
+ SDL_DisplayID* displays = SDL_GetDisplays(&display_count);
+ for (int n = 0; n < display_count; n++)
+ {
+ // 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.
+ SDL_DisplayID display_id = displays[n];
+ ImGuiPlatformMonitor monitor;
+ SDL_Rect r;
+ SDL_GetDisplayBounds(display_id, &r);
+ monitor.MainPos = monitor.WorkPos = ImVec2((float)r.x, (float)r.y);
+ monitor.MainSize = monitor.WorkSize = ImVec2((float)r.w, (float)r.h);
+ SDL_GetDisplayUsableBounds(display_id, &r);
+ monitor.WorkPos = ImVec2((float)r.x, (float)r.y);
+ monitor.WorkSize = ImVec2((float)r.w, (float)r.h);
+ // FIXME-VIEWPORT: On MacOS SDL reports actual monitor DPI scale, ignoring OS configuration. We may want to set
+ // DpiScale to cocoa_window.backingScaleFactor here.
+ monitor.DpiScale = SDL_GetDisplayContentScale(display_id);
+ monitor.PlatformHandle = (void*)(intptr_t)n;
+ if (monitor.DpiScale <= 0.0f)
+ continue; // Some accessibility applications are declaring virtual monitors with a DPI of 0, see #7902.
+ platform_io.Monitors.push_back(monitor);
+ }
+ SDL_free(displays);
+}
+
void ImGui_ImplSDL3_NewFrame()
{
ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
@@ -738,6 +861,10 @@
if (w > 0 && h > 0)
io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
+ // Update monitors
+ if (bd->WantUpdateMonitors)
+ ImGui_ImplSDL3_UpdateMonitors();
+
// Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
// (Accept SDL_GetPerformanceCounter() not returning a monotonically increasing value. Happens in VMs and Emscripten, see #6189, #6114, #3644)
static Uint64 frequency = SDL_GetPerformanceFrequency();
@@ -754,6 +881,13 @@
io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
}
+ // Our io.AddMouseViewportEvent() calls will only be valid when not capturing.
+ // Technically speaking testing for 'bd->MouseButtonsDown == 0' would be more rigorous, but testing for payload reduces noise and potential side-effects.
+ if (bd->MouseCanReportHoveredViewport && ImGui::GetDragDropPayload() == nullptr)
+ io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport;
+ else
+ io.BackendFlags &= ~ImGuiBackendFlags_HasMouseHoveredViewport;
+
ImGui_ImplSDL3_UpdateMouseData();
ImGui_ImplSDL3_UpdateMouseCursor();
@@ -761,6 +895,226 @@
ImGui_ImplSDL3_UpdateGamepads();
}
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplSDL3_ViewportData
+{
+ SDL_Window* Window;
+ Uint32 WindowID;
+ bool WindowOwned;
+ SDL_GLContext GLContext;
+
+ ImGui_ImplSDL3_ViewportData() { Window = nullptr; WindowID = 0; WindowOwned = false; GLContext = nullptr; }
+ ~ImGui_ImplSDL3_ViewportData() { IM_ASSERT(Window == nullptr && GLContext == nullptr); }
+};
+
+static void ImGui_ImplSDL3_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_Data* bd = ImGui_ImplSDL3_GetBackendData();
+ ImGui_ImplSDL3_ViewportData* vd = IM_NEW(ImGui_ImplSDL3_ViewportData)();
+ viewport->PlatformUserData = vd;
+
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGui_ImplSDL3_ViewportData* main_viewport_data = (ImGui_ImplSDL3_ViewportData*)main_viewport->PlatformUserData;
+
+ // Share GL resources with main context
+ bool use_opengl = (main_viewport_data->GLContext != nullptr);
+ SDL_GLContext backup_context = nullptr;
+ if (use_opengl)
+ {
+ backup_context = SDL_GL_GetCurrentContext();
+ SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
+ SDL_GL_MakeCurrent(main_viewport_data->Window, main_viewport_data->GLContext);
+ }
+
+ Uint32 sdl_flags = 0;
+ sdl_flags |= use_opengl ? SDL_WINDOW_OPENGL : (bd->UseVulkan ? SDL_WINDOW_VULKAN : 0);
+ sdl_flags |= SDL_GetWindowFlags(bd->Window);
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? SDL_WINDOW_BORDERLESS : 0;
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoDecoration) ? 0 : SDL_WINDOW_RESIZABLE;
+#if !defined(_WIN32)
+ // See SDL hack in ImGui_ImplSDL3_ShowWindow().
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon) ? SDL_WINDOW_UTILITY : 0;
+#endif
+ sdl_flags |= (viewport->Flags & ImGuiViewportFlags_TopMost) ? SDL_WINDOW_ALWAYS_ON_TOP : 0;
+ vd->Window = SDL_CreateWindow("No Title Yet", (int)viewport->Size.x, (int)viewport->Size.y, sdl_flags);
+ SDL_SetWindowPosition(vd->Window, (int)viewport->Pos.x, (int)viewport->Pos.y);
+ vd->WindowOwned = true;
+ if (use_opengl)
+ {
+ vd->GLContext = SDL_GL_CreateContext(vd->Window);
+ SDL_GL_SetSwapInterval(0);
+ }
+ if (use_opengl && backup_context)
+ SDL_GL_MakeCurrent(vd->Window, backup_context);
+
+ ImGui_ImplSDL3_SetupPlatformHandles(viewport, vd->Window);
+}
+
+static void ImGui_ImplSDL3_DestroyWindow(ImGuiViewport* viewport)
+{
+ if (ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData)
+ {
+ if (vd->GLContext && vd->WindowOwned)
+ SDL_GL_DestroyContext(vd->GLContext);
+ if (vd->Window && vd->WindowOwned)
+ SDL_DestroyWindow(vd->Window);
+ vd->GLContext = nullptr;
+ vd->Window = nullptr;
+ IM_DELETE(vd);
+ }
+ viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
+}
+
+static void ImGui_ImplSDL3_ShowWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+#if defined(_WIN32)
+ HWND hwnd = (HWND)viewport->PlatformHandleRaw;
+
+ // SDL hack: Hide icon from task bar
+ // Note: SDL 3.0.0+ has a SDL_WINDOW_UTILITY flag which is supported under Windows but the way it create the window breaks our seamless transition.
+ if (viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon)
+ {
+ LONG ex_style = ::GetWindowLong(hwnd, GWL_EXSTYLE);
+ ex_style &= ~WS_EX_APPWINDOW;
+ ex_style |= WS_EX_TOOLWINDOW;
+ ::SetWindowLong(hwnd, GWL_EXSTYLE, ex_style);
+ }
+#endif
+
+ SDL_SetHint(SDL_HINT_WINDOW_ACTIVATE_WHEN_SHOWN, (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing) ? "0" : "1");
+ SDL_ShowWindow(vd->Window);
+}
+
+static ImVec2 ImGui_ImplSDL3_GetWindowPos(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ int x = 0, y = 0;
+ SDL_GetWindowPosition(vd->Window, &x, &y);
+ return ImVec2((float)x, (float)y);
+}
+
+static void ImGui_ImplSDL3_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowPosition(vd->Window, (int)pos.x, (int)pos.y);
+}
+
+static ImVec2 ImGui_ImplSDL3_GetWindowSize(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ int w = 0, h = 0;
+ SDL_GetWindowSize(vd->Window, &w, &h);
+ return ImVec2((float)w, (float)h);
+}
+
+static void ImGui_ImplSDL3_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowSize(vd->Window, (int)size.x, (int)size.y);
+}
+
+static void ImGui_ImplSDL3_SetWindowTitle(ImGuiViewport* viewport, const char* title)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowTitle(vd->Window, title);
+}
+
+static void ImGui_ImplSDL3_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ SDL_SetWindowOpacity(vd->Window, alpha);
+}
+
+static void ImGui_ImplSDL3_SetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ SDL_RaiseWindow(vd->Window);
+}
+
+static bool ImGui_ImplSDL3_GetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_INPUT_FOCUS) != 0;
+}
+
+static bool ImGui_ImplSDL3_GetWindowMinimized(ImGuiViewport* viewport)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ return (SDL_GetWindowFlags(vd->Window) & SDL_WINDOW_MINIMIZED) != 0;
+}
+
+static void ImGui_ImplSDL3_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ if (vd->GLContext)
+ SDL_GL_MakeCurrent(vd->Window, vd->GLContext);
+}
+
+static void ImGui_ImplSDL3_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ if (vd->GLContext)
+ {
+ SDL_GL_MakeCurrent(vd->Window, vd->GLContext);
+ SDL_GL_SwapWindow(vd->Window);
+ }
+}
+
+// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
+// SDL is graceful enough to _not_ need <vulkan/vulkan.h> so we can safely include this.
+#include <SDL3/SDL_vulkan.h>
+static int ImGui_ImplSDL3_CreateVkSurface(ImGuiViewport* viewport, ImU64 vk_instance, const void* vk_allocator, ImU64* out_vk_surface)
+{
+ ImGui_ImplSDL3_ViewportData* vd = (ImGui_ImplSDL3_ViewportData*)viewport->PlatformUserData;
+ (void)vk_allocator;
+ SDL_bool ret = SDL_Vulkan_CreateSurface(vd->Window, (VkInstance)vk_instance, (VkAllocationCallbacks*)vk_allocator, (VkSurfaceKHR*)out_vk_surface);
+ return ret ? 0 : 1; // ret ? VK_SUCCESS : VK_NOT_READY
+}
+
+static void ImGui_ImplSDL3_InitPlatformInterface(SDL_Window* window, void* sdl_gl_context)
+{
+ // Register platform interface (will be coupled with a renderer interface)
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Platform_CreateWindow = ImGui_ImplSDL3_CreateWindow;
+ platform_io.Platform_DestroyWindow = ImGui_ImplSDL3_DestroyWindow;
+ platform_io.Platform_ShowWindow = ImGui_ImplSDL3_ShowWindow;
+ platform_io.Platform_SetWindowPos = ImGui_ImplSDL3_SetWindowPos;
+ platform_io.Platform_GetWindowPos = ImGui_ImplSDL3_GetWindowPos;
+ platform_io.Platform_SetWindowSize = ImGui_ImplSDL3_SetWindowSize;
+ platform_io.Platform_GetWindowSize = ImGui_ImplSDL3_GetWindowSize;
+ platform_io.Platform_SetWindowFocus = ImGui_ImplSDL3_SetWindowFocus;
+ platform_io.Platform_GetWindowFocus = ImGui_ImplSDL3_GetWindowFocus;
+ platform_io.Platform_GetWindowMinimized = ImGui_ImplSDL3_GetWindowMinimized;
+ platform_io.Platform_SetWindowTitle = ImGui_ImplSDL3_SetWindowTitle;
+ platform_io.Platform_RenderWindow = ImGui_ImplSDL3_RenderWindow;
+ platform_io.Platform_SwapBuffers = ImGui_ImplSDL3_SwapBuffers;
+ platform_io.Platform_SetWindowAlpha = ImGui_ImplSDL3_SetWindowAlpha;
+ platform_io.Platform_CreateVkSurface = ImGui_ImplSDL3_CreateVkSurface;
+
+ // Register main window handle (which is owned by the main application, not by us)
+ // 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.
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGui_ImplSDL3_ViewportData* vd = IM_NEW(ImGui_ImplSDL3_ViewportData)();
+ vd->Window = window;
+ vd->WindowID = SDL_GetWindowID(window);
+ vd->WindowOwned = false;
+ vd->GLContext = (SDL_GLContext)sdl_gl_context;
+ main_viewport->PlatformUserData = vd;
+ main_viewport->PlatformHandle = (void*)(intptr_t)vd->WindowID;
+}
+
+static void ImGui_ImplSDL3_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#if defined(__clang__)
diff --git a/backends/imgui_impl_sdl3.h b/backends/imgui_impl_sdl3.h
index 880ba96..f638fd7 100644
--- a/backends/imgui_impl_sdl3.h
+++ b/backends/imgui_impl_sdl3.h
@@ -10,6 +10,11 @@
// [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]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+// [x] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable' -> the OS animation effect when window gets created/destroyed is problematic. SDL2 backend doesn't have issue.
+// Issues:
+// [ ] Platform: Multi-viewport: Minimized windows seems to break mouse wheel events (at least under Windows).
+// [ ] Platform: Multi-viewport: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
+// [x] Platform: Basic IME support. Position somehow broken in SDL3 + app needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_sdlrenderer2.cpp b/backends/imgui_impl_sdlrenderer2.cpp
index 3d538df..a046ed9 100644
--- a/backends/imgui_impl_sdlrenderer2.cpp
+++ b/backends/imgui_impl_sdlrenderer2.cpp
@@ -10,6 +10,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows).
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_sdlrenderer2.h b/backends/imgui_impl_sdlrenderer2.h
index c067eae..0a135ad 100644
--- a/backends/imgui_impl_sdlrenderer2.h
+++ b/backends/imgui_impl_sdlrenderer2.h
@@ -10,6 +10,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows).
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_sdlrenderer3.cpp b/backends/imgui_impl_sdlrenderer3.cpp
index d3926c2..45a69ba 100644
--- a/backends/imgui_impl_sdlrenderer3.cpp
+++ b/backends/imgui_impl_sdlrenderer3.cpp
@@ -12,6 +12,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows).
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_sdlrenderer3.h b/backends/imgui_impl_sdlrenderer3.h
index 6c23dec..4ae96dc 100644
--- a/backends/imgui_impl_sdlrenderer3.h
+++ b/backends/imgui_impl_sdlrenderer3.h
@@ -12,6 +12,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows).
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_vulkan.cpp b/backends/imgui_impl_vulkan.cpp
index 3b757eb..cb54fa1 100644
--- a/backends/imgui_impl_vulkan.cpp
+++ b/backends/imgui_impl_vulkan.cpp
@@ -2,8 +2,9 @@
// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
// Implemented features:
-// [!] Renderer: User texture binding. Use 'VkDescriptorSet' as ImTextureID. Read the FAQ about ImTextureID! See https://github.com/ocornut/imgui/pull/914 for discussions.
+// [x] Renderer: User texture binding. Use 'VkDescriptorSet' as ImTextureID. Read the FAQ about ImTextureID! See https://github.com/ocornut/imgui/pull/914 for discussions.
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [x] Renderer: Multi-viewport / platform windows. With issues (flickering when creating a new viewport).
// Important: on 32-bit systems, user texture binding is only supported if your imconfig file has '#define ImTextureID ImU64'.
// This is because we need ImTextureID to carry a 64-bit value and by default ImTextureID is defined as void*.
@@ -33,6 +34,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-04-19: Vulkan: Added convenience support for Volk via IMGUI_IMPL_VULKAN_USE_VOLK define (you can also use IMGUI_IMPL_VULKAN_NO_PROTOTYPES + wrap Volk via ImGui_ImplVulkan_LoadFunctions().)
// 2024-02-14: *BREAKING CHANGE*: Moved RenderPass parameter from ImGui_ImplVulkan_Init() function to ImGui_ImplVulkan_InitInfo structure. Not required when using dynamic rendering.
// 2024-02-12: *BREAKING CHANGE*: Dynamic rendering now require filling PipelineRenderingCreateInfo structure.
@@ -104,6 +106,7 @@
void ImGui_ImplVulkan_DestroyWindowRenderBuffers(VkDevice device, ImGui_ImplVulkan_WindowRenderBuffers* buffers, const VkAllocationCallbacks* allocator);
void ImGui_ImplVulkanH_DestroyFrame(VkDevice device, ImGui_ImplVulkanH_Frame* fd, const VkAllocationCallbacks* allocator);
void ImGui_ImplVulkanH_DestroyFrameSemaphores(VkDevice device, ImGui_ImplVulkanH_FrameSemaphores* fsd, const VkAllocationCallbacks* allocator);
+void ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(VkDevice device, const VkAllocationCallbacks* allocator);
void ImGui_ImplVulkanH_CreateWindowSwapChain(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
void ImGui_ImplVulkanH_CreateWindowCommandBuffers(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, uint32_t queue_family, const VkAllocationCallbacks* allocator);
@@ -120,15 +123,18 @@
IMGUI_VULKAN_FUNC_MAP_MACRO(vkAllocateCommandBuffers) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkAllocateDescriptorSets) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkAllocateMemory) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkAcquireNextImageKHR) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkBeginCommandBuffer) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkBindBufferMemory) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkBindImageMemory) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdBeginRenderPass) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdBindDescriptorSets) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdBindIndexBuffer) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdBindPipeline) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdBindVertexBuffers) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdCopyBufferToImage) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdDrawIndexed) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdEndRenderPass) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdPipelineBarrier) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdPushConstants) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkCmdSetScissor) \
@@ -174,13 +180,17 @@
IMGUI_VULKAN_FUNC_MAP_MACRO(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkGetPhysicalDeviceSurfaceFormatsKHR) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkGetPhysicalDeviceSurfacePresentModesKHR) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkGetPhysicalDeviceSurfaceSupportKHR) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkGetSwapchainImagesKHR) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkMapMemory) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkQueuePresentKHR) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkQueueSubmit) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkQueueWaitIdle) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkResetCommandPool) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkResetFences) \
IMGUI_VULKAN_FUNC_MAP_MACRO(vkUnmapMemory) \
- IMGUI_VULKAN_FUNC_MAP_MACRO(vkUpdateDescriptorSets)
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkUpdateDescriptorSets) \
+ IMGUI_VULKAN_FUNC_MAP_MACRO(vkWaitForFences)
// Define function pointers
#define IMGUI_VULKAN_FUNC_DEF(func) static PFN_##func func;
@@ -214,6 +224,19 @@
ImGui_ImplVulkan_FrameRenderBuffers* FrameRenderBuffers;
};
+// For multi-viewport support:
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplVulkan_ViewportData
+{
+ ImGui_ImplVulkanH_Window Window; // Used by secondary viewports only
+ ImGui_ImplVulkan_WindowRenderBuffers RenderBuffers; // Used by all viewports
+ bool WindowOwned;
+ bool SwapChainNeedRebuild; // Flag when viewport swapchain resized in the middle of processing a frame
+
+ ImGui_ImplVulkan_ViewportData() { WindowOwned = SwapChainNeedRebuild = false; memset(&RenderBuffers, 0, sizeof(RenderBuffers)); }
+ ~ImGui_ImplVulkan_ViewportData() { }
+};
+
// Vulkan data
struct ImGui_ImplVulkan_Data
{
@@ -222,7 +245,8 @@
VkPipelineCreateFlags PipelineCreateFlags;
VkDescriptorSetLayout DescriptorSetLayout;
VkPipelineLayout PipelineLayout;
- VkPipeline Pipeline;
+ VkPipeline Pipeline; // pipeline for main render pass (created by app)
+ VkPipeline PipelineForViewports; // pipeline for secondary viewports (created by backend)
VkShaderModule ShaderModuleVert;
VkShaderModule ShaderModuleFrag;
@@ -249,6 +273,10 @@
// SHADERS
//-----------------------------------------------------------------------------
+// Forward Declarations
+static void ImGui_ImplVulkan_InitPlatformInterface();
+static void ImGui_ImplVulkan_ShutdownPlatformInterface();
+
// backends/vulkan/glsl_shader.vert, compiled with:
// # glslangValidator -V -x -o glsl_shader.vert.u32 glsl_shader.vert
/*
@@ -486,8 +514,10 @@
if (pipeline == VK_NULL_HANDLE)
pipeline = bd->Pipeline;
- // Allocate array to store enough vertex/index buffers
- ImGui_ImplVulkan_WindowRenderBuffers* wrb = &bd->MainWindowRenderBuffers;
+ // Allocate array to store enough vertex/index buffers. Each unique viewport gets its own storage.
+ ImGui_ImplVulkan_ViewportData* viewport_renderer_data = (ImGui_ImplVulkan_ViewportData*)draw_data->OwnerViewport->RendererUserData;
+ IM_ASSERT(viewport_renderer_data != nullptr);
+ ImGui_ImplVulkan_WindowRenderBuffers* wrb = &viewport_renderer_data->RenderBuffers;
if (wrb->FrameRenderBuffers == nullptr)
{
wrb->Index = 0;
@@ -1032,7 +1062,7 @@
{
ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData();
ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
- ImGui_ImplVulkan_DestroyWindowRenderBuffers(v->Device, &bd->MainWindowRenderBuffers, v->Allocator);
+ ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(v->Device, v->Allocator);
ImGui_ImplVulkan_DestroyFontsTexture();
if (bd->FontCommandBuffer) { vkFreeCommandBuffers(v->Device, bd->FontCommandPool, 1, &bd->FontCommandBuffer); bd->FontCommandBuffer = VK_NULL_HANDLE; }
@@ -1043,6 +1073,7 @@
if (bd->DescriptorSetLayout) { vkDestroyDescriptorSetLayout(v->Device, bd->DescriptorSetLayout, v->Allocator); bd->DescriptorSetLayout = VK_NULL_HANDLE; }
if (bd->PipelineLayout) { vkDestroyPipelineLayout(v->Device, bd->PipelineLayout, v->Allocator); bd->PipelineLayout = VK_NULL_HANDLE; }
if (bd->Pipeline) { vkDestroyPipeline(v->Device, bd->Pipeline, v->Allocator); bd->Pipeline = VK_NULL_HANDLE; }
+ if (bd->PipelineForViewports) { vkDestroyPipeline(v->Device, bd->PipelineForViewports, v->Allocator); bd->PipelineForViewports = VK_NULL_HANDLE; }
}
bool ImGui_ImplVulkan_LoadFunctions(PFN_vkVoidFunction(*loader_func)(const char* function_name, void* user_data), void* user_data)
@@ -1100,6 +1131,7 @@
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_vulkan";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+ io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports; // We can create multi-viewports on the Renderer side (optional)
IM_ASSERT(info->Instance != VK_NULL_HANDLE);
IM_ASSERT(info->PhysicalDevice != VK_NULL_HANDLE);
@@ -1115,6 +1147,13 @@
ImGui_ImplVulkan_CreateDeviceObjects();
+ // Our render function expect RendererUserData to be storing the window render buffer we need (for the main viewport we won't use ->Window)
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ main_viewport->RendererUserData = IM_NEW(ImGui_ImplVulkan_ViewportData)();
+
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplVulkan_InitPlatformInterface();
+
return true;
}
@@ -1124,10 +1163,21 @@
IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ // First destroy objects in all viewports
ImGui_ImplVulkan_DestroyDeviceObjects();
+
+ // Manually delete main viewport render data in-case we haven't initialized for viewports
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ if (ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)main_viewport->RendererUserData)
+ IM_DELETE(vd);
+ main_viewport->RendererUserData = nullptr;
+
+ // Clean up windows
+ ImGui_ImplVulkan_ShutdownPlatformInterface();
+
io.BackendRendererName = nullptr;
io.BackendRendererUserData = nullptr;
- io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+ io.BackendFlags &= ~(ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasViewports);
IM_DELETE(bd);
}
@@ -1147,10 +1197,12 @@
if (bd->VulkanInitInfo.MinImageCount == min_image_count)
return;
+ IM_ASSERT(0); // FIXME-VIEWPORT: Unsupported. Need to recreate all swap chains!
ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
VkResult err = vkDeviceWaitIdle(v->Device);
check_vk_result(err);
- ImGui_ImplVulkan_DestroyWindowRenderBuffers(v->Device, &bd->MainWindowRenderBuffers, v->Allocator);
+ ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(v->Device, v->Allocator);
+
bd->VulkanInitInfo.MinImageCount = min_image_count;
}
@@ -1385,8 +1437,6 @@
wd->ImageCount = 0;
if (wd->RenderPass)
vkDestroyRenderPass(device, wd->RenderPass, allocator);
- if (wd->Pipeline)
- vkDestroyPipeline(device, wd->Pipeline, allocator);
// If min image count was not specified, request different count of images dependent on selected present mode
if (min_image_count == 0)
@@ -1539,6 +1589,7 @@
IM_ASSERT(g_FunctionsLoaded && "Need to call ImGui_ImplVulkan_LoadFunctions() if IMGUI_IMPL_VULKAN_NO_PROTOTYPES or VK_NO_PROTOTYPES are set!");
(void)instance;
ImGui_ImplVulkanH_CreateWindowSwapChain(physical_device, device, wd, allocator, width, height, min_image_count);
+ //ImGui_ImplVulkan_CreatePipeline(device, allocator, VK_NULL_HANDLE, wd->RenderPass, VK_SAMPLE_COUNT_1_BIT, &wd->Pipeline, g_VulkanInitInfo.Subpass);
ImGui_ImplVulkanH_CreateWindowCommandBuffers(physical_device, device, wd, queue_family, allocator);
}
@@ -1555,7 +1606,6 @@
IM_FREE(wd->FrameSemaphores);
wd->Frames = nullptr;
wd->FrameSemaphores = nullptr;
- vkDestroyPipeline(device, wd->Pipeline, allocator);
vkDestroyRenderPass(device, wd->RenderPass, allocator);
vkDestroySwapchainKHR(device, wd->Swapchain, allocator);
vkDestroySurfaceKHR(instance, wd->Surface, allocator);
@@ -1583,6 +1633,297 @@
fsd->ImageAcquiredSemaphore = fsd->RenderCompleteSemaphore = VK_NULL_HANDLE;
}
+void ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(VkDevice device, const VkAllocationCallbacks* allocator)
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int n = 0; n < platform_io.Viewports.Size; n++)
+ if (ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)platform_io.Viewports[n]->RendererUserData)
+ ImGui_ImplVulkan_DestroyWindowRenderBuffers(device, &vd->RenderBuffers, allocator);
+}
+
+//--------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+static void ImGui_ImplVulkan_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData();
+ ImGui_ImplVulkan_ViewportData* vd = IM_NEW(ImGui_ImplVulkan_ViewportData)();
+ viewport->RendererUserData = vd;
+ ImGui_ImplVulkanH_Window* wd = &vd->Window;
+ ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
+
+ // Create surface
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ VkResult err = (VkResult)platform_io.Platform_CreateVkSurface(viewport, (ImU64)v->Instance, (const void*)v->Allocator, (ImU64*)&wd->Surface);
+ check_vk_result(err);
+
+ // Check for WSI support
+ VkBool32 res;
+ vkGetPhysicalDeviceSurfaceSupportKHR(v->PhysicalDevice, v->QueueFamily, wd->Surface, &res);
+ if (res != VK_TRUE)
+ {
+ IM_ASSERT(0); // Error: no WSI support on physical device
+ return;
+ }
+
+ // Select Surface Format
+ ImVector<VkFormat> requestSurfaceImageFormats;
+#ifdef IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING
+ for (uint32_t n = 0; n < v->PipelineRenderingCreateInfo.colorAttachmentCount; n++)
+ requestSurfaceImageFormats.push_back(v->PipelineRenderingCreateInfo.pColorAttachmentFormats[n]);
+#endif
+ const VkFormat defaultFormats[] = { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM };
+ for (VkFormat format : defaultFormats)
+ requestSurfaceImageFormats.push_back(format);
+
+ const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+ wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(v->PhysicalDevice, wd->Surface, requestSurfaceImageFormats.Data, (size_t)requestSurfaceImageFormats.Size, requestSurfaceColorSpace);
+
+ // Select Present Mode
+ // FIXME-VULKAN: Even thought mailbox seems to get us maximum framerate with a single window, it halves framerate with a second window etc. (w/ Nvidia and SDK 1.82.1)
+ VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR };
+ wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(v->PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+ //printf("[vulkan] Secondary window selected PresentMode = %d\n", wd->PresentMode);
+
+ // Create SwapChain, RenderPass, Framebuffer, etc.
+ wd->ClearEnable = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? false : true;
+ wd->UseDynamicRendering = v->UseDynamicRendering;
+ ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, wd, v->QueueFamily, v->Allocator, (int)viewport->Size.x, (int)viewport->Size.y, v->MinImageCount);
+ vd->WindowOwned = true;
+
+ // Create pipeline (shared by all secondary viewports)
+ if (bd->PipelineForViewports == VK_NULL_HANDLE)
+ ImGui_ImplVulkan_CreatePipeline(v->Device, v->Allocator, VK_NULL_HANDLE, wd->RenderPass, VK_SAMPLE_COUNT_1_BIT, &bd->PipelineForViewports, 0);
+}
+
+static void ImGui_ImplVulkan_DestroyWindow(ImGuiViewport* viewport)
+{
+ // The main viewport (owned by the application) will always have RendererUserData == 0 since we didn't create the data for it.
+ ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData();
+ if (ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData)
+ {
+ ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
+ if (vd->WindowOwned)
+ ImGui_ImplVulkanH_DestroyWindow(v->Instance, v->Device, &vd->Window, v->Allocator);
+ ImGui_ImplVulkan_DestroyWindowRenderBuffers(v->Device, &vd->RenderBuffers, v->Allocator);
+ IM_DELETE(vd);
+ }
+ viewport->RendererUserData = nullptr;
+}
+
+static void ImGui_ImplVulkan_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData();
+ ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData;
+ if (vd == nullptr) // This is nullptr for the main viewport (which is left to the user/app to handle)
+ return;
+ ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
+ vd->Window.ClearEnable = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? false : true;
+ ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, &vd->Window, v->QueueFamily, v->Allocator, (int)size.x, (int)size.y, v->MinImageCount);
+}
+
+static void ImGui_ImplVulkan_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData();
+ ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData;
+ ImGui_ImplVulkanH_Window* wd = &vd->Window;
+ ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
+ VkResult err;
+
+ if (vd->SwapChainNeedRebuild)
+ {
+ ImGui_ImplVulkanH_CreateOrResizeWindow(v->Instance, v->PhysicalDevice, v->Device, wd, v->QueueFamily, v->Allocator, (int)viewport->Size.x, (int)viewport->Size.y, v->MinImageCount);
+ vd->SwapChainNeedRebuild = false;
+ }
+
+ ImGui_ImplVulkanH_Frame* fd = &wd->Frames[wd->FrameIndex];
+ ImGui_ImplVulkanH_FrameSemaphores* fsd = &wd->FrameSemaphores[wd->SemaphoreIndex];
+ {
+ {
+ err = vkAcquireNextImageKHR(v->Device, wd->Swapchain, UINT64_MAX, fsd->ImageAcquiredSemaphore, VK_NULL_HANDLE, &wd->FrameIndex);
+ if (err == VK_ERROR_OUT_OF_DATE_KHR)
+ {
+ // Since we are not going to swap this frame anyway, it's ok that recreation happens on next frame.
+ vd->SwapChainNeedRebuild = true;
+ return;
+ }
+ check_vk_result(err);
+ fd = &wd->Frames[wd->FrameIndex];
+ }
+ for (;;)
+ {
+ err = vkWaitForFences(v->Device, 1, &fd->Fence, VK_TRUE, 100);
+ if (err == VK_SUCCESS) break;
+ if (err == VK_TIMEOUT) continue;
+ check_vk_result(err);
+ }
+ {
+ err = vkResetCommandPool(v->Device, fd->CommandPool, 0);
+ check_vk_result(err);
+ VkCommandBufferBeginInfo info = {};
+ info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+ err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
+ check_vk_result(err);
+ }
+ {
+ ImVec4 clear_color = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
+ memcpy(&wd->ClearValue.color.float32[0], &clear_color, 4 * sizeof(float));
+ }
+#ifdef IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING
+ if (v->UseDynamicRendering)
+ {
+ // Transition swapchain image to a layout suitable for drawing.
+ VkImageMemoryBarrier barrier = {};
+ barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+ barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+ barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ barrier.image = fd->Backbuffer;
+ barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ barrier.subresourceRange.levelCount = 1;
+ barrier.subresourceRange.layerCount = 1;
+ vkCmdPipelineBarrier(fd->CommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+
+ VkRenderingAttachmentInfo attachmentInfo = {};
+ attachmentInfo.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR;
+ attachmentInfo.imageView = fd->BackbufferView;
+ attachmentInfo.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ attachmentInfo.resolveMode = VK_RESOLVE_MODE_NONE;
+ attachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+ attachmentInfo.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+ attachmentInfo.clearValue = wd->ClearValue;
+
+ VkRenderingInfo renderingInfo = {};
+ renderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO_KHR;
+ renderingInfo.renderArea.extent.width = wd->Width;
+ renderingInfo.renderArea.extent.height = wd->Height;
+ renderingInfo.layerCount = 1;
+ renderingInfo.viewMask = 0;
+ renderingInfo.colorAttachmentCount = 1;
+ renderingInfo.pColorAttachments = &attachmentInfo;
+
+ ImGuiImplVulkanFuncs_vkCmdBeginRenderingKHR(fd->CommandBuffer, &renderingInfo);
+ }
+ else
+#endif
+ {
+ VkRenderPassBeginInfo info = {};
+ info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+ info.renderPass = wd->RenderPass;
+ info.framebuffer = fd->Framebuffer;
+ info.renderArea.extent.width = wd->Width;
+ info.renderArea.extent.height = wd->Height;
+ info.clearValueCount = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? 0 : 1;
+ info.pClearValues = (viewport->Flags & ImGuiViewportFlags_NoRendererClear) ? nullptr : &wd->ClearValue;
+ vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);
+ }
+ }
+
+ ImGui_ImplVulkan_RenderDrawData(viewport->DrawData, fd->CommandBuffer, bd->PipelineForViewports);
+
+ {
+#ifdef IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING
+ if (v->UseDynamicRendering)
+ {
+ ImGuiImplVulkanFuncs_vkCmdEndRenderingKHR(fd->CommandBuffer);
+
+ // Transition image to a layout suitable for presentation
+ VkImageMemoryBarrier barrier = {};
+ barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+ barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+ barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+ barrier.image = fd->Backbuffer;
+ barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+ barrier.subresourceRange.levelCount = 1;
+ barrier.subresourceRange.layerCount = 1;
+ vkCmdPipelineBarrier(fd->CommandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+ }
+ else
+#endif
+ {
+ vkCmdEndRenderPass(fd->CommandBuffer);
+ }
+ {
+ VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+ VkSubmitInfo info = {};
+ info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+ info.waitSemaphoreCount = 1;
+ info.pWaitSemaphores = &fsd->ImageAcquiredSemaphore;
+ info.pWaitDstStageMask = &wait_stage;
+ info.commandBufferCount = 1;
+ info.pCommandBuffers = &fd->CommandBuffer;
+ info.signalSemaphoreCount = 1;
+ info.pSignalSemaphores = &fsd->RenderCompleteSemaphore;
+
+ err = vkEndCommandBuffer(fd->CommandBuffer);
+ check_vk_result(err);
+ err = vkResetFences(v->Device, 1, &fd->Fence);
+ check_vk_result(err);
+ err = vkQueueSubmit(v->Queue, 1, &info, fd->Fence);
+ check_vk_result(err);
+ }
+ }
+}
+
+static void ImGui_ImplVulkan_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ ImGui_ImplVulkan_Data* bd = ImGui_ImplVulkan_GetBackendData();
+ ImGui_ImplVulkan_ViewportData* vd = (ImGui_ImplVulkan_ViewportData*)viewport->RendererUserData;
+ ImGui_ImplVulkanH_Window* wd = &vd->Window;
+ ImGui_ImplVulkan_InitInfo* v = &bd->VulkanInitInfo;
+
+ if (vd->SwapChainNeedRebuild) // Frame data became invalid in the middle of rendering
+ return;
+
+ VkResult err;
+ uint32_t present_index = wd->FrameIndex;
+
+ ImGui_ImplVulkanH_FrameSemaphores* fsd = &wd->FrameSemaphores[wd->SemaphoreIndex];
+ VkPresentInfoKHR info = {};
+ info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+ info.waitSemaphoreCount = 1;
+ info.pWaitSemaphores = &fsd->RenderCompleteSemaphore;
+ info.swapchainCount = 1;
+ info.pSwapchains = &wd->Swapchain;
+ info.pImageIndices = &present_index;
+ err = vkQueuePresentKHR(v->Queue, &info);
+ if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+ {
+ vd->SwapChainNeedRebuild = true;
+ if (err == VK_ERROR_OUT_OF_DATE_KHR)
+ return;
+ }
+ else
+ {
+ check_vk_result(err);
+ }
+
+ wd->FrameIndex = (wd->FrameIndex + 1) % wd->ImageCount; // This is for the next vkWaitForFences()
+ wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->SemaphoreCount; // Now we can use the next set of semaphores
+}
+
+void ImGui_ImplVulkan_InitPlatformInterface()
+{
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ IM_ASSERT(platform_io.Platform_CreateVkSurface != nullptr && "Platform needs to setup the CreateVkSurface handler.");
+ platform_io.Renderer_CreateWindow = ImGui_ImplVulkan_CreateWindow;
+ platform_io.Renderer_DestroyWindow = ImGui_ImplVulkan_DestroyWindow;
+ platform_io.Renderer_SetWindowSize = ImGui_ImplVulkan_SetWindowSize;
+ platform_io.Renderer_RenderWindow = ImGui_ImplVulkan_RenderWindow;
+ platform_io.Renderer_SwapBuffers = ImGui_ImplVulkan_SwapBuffers;
+}
+
+void ImGui_ImplVulkan_ShutdownPlatformInterface()
+{
+ ImGui::DestroyPlatformWindows();
+}
+
//-----------------------------------------------------------------------------
#endif // #ifndef IMGUI_DISABLE
diff --git a/backends/imgui_impl_vulkan.h b/backends/imgui_impl_vulkan.h
index 1c7f769..22df982 100644
--- a/backends/imgui_impl_vulkan.h
+++ b/backends/imgui_impl_vulkan.h
@@ -2,8 +2,9 @@
// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
// Implemented features:
-// [!] Renderer: User texture binding. Use 'VkDescriptorSet' as ImTextureID. Read the FAQ about ImTextureID! See https://github.com/ocornut/imgui/pull/914 for discussions.
+// [x] Renderer: User texture binding. Use 'VkDescriptorSet' as ImTextureID. Read the FAQ about ImTextureID! See https://github.com/ocornut/imgui/pull/914 for discussions.
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// [x] Renderer: Multi-viewport / platform windows. With issues (flickering when creating a new viewport).
// Important: on 32-bit systems, user texture binding is only supported if your imconfig file has '#define ImTextureID ImU64'.
// See imgui_impl_vulkan.cpp file for details.
@@ -137,8 +138,8 @@
struct ImGui_ImplVulkanH_Window;
// Helpers
-IMGUI_IMPL_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wnd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
-IMGUI_IMPL_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance, VkDevice device, ImGui_ImplVulkanH_Window* wnd, const VkAllocationCallbacks* allocator);
+IMGUI_IMPL_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
+IMGUI_IMPL_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance, VkDevice device, ImGui_ImplVulkanH_Window* wd, const VkAllocationCallbacks* allocator);
IMGUI_IMPL_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkFormat* request_formats, int request_formats_count, VkColorSpaceKHR request_color_space);
IMGUI_IMPL_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkPresentModeKHR* request_modes, int request_modes_count);
IMGUI_IMPL_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
@@ -173,7 +174,6 @@
VkSurfaceFormatKHR SurfaceFormat;
VkPresentModeKHR PresentMode;
VkRenderPass RenderPass;
- VkPipeline Pipeline; // The window pipeline may uses a different VkRenderPass than the one passed in ImGui_ImplVulkan_InitInfo
bool UseDynamicRendering;
bool ClearEnable;
VkClearValue ClearValue;
diff --git a/backends/imgui_impl_wgpu.cpp b/backends/imgui_impl_wgpu.cpp
index bf741e1..ceee552 100644
--- a/backends/imgui_impl_wgpu.cpp
+++ b/backends/imgui_impl_wgpu.cpp
@@ -5,6 +5,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'WGPUTextureView' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows). Not meaningful on the web.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_wgpu.h b/backends/imgui_impl_wgpu.h
index 87d9580..31d31c9 100644
--- a/backends/imgui_impl_wgpu.h
+++ b/backends/imgui_impl_wgpu.h
@@ -5,6 +5,8 @@
// Implemented features:
// [X] Renderer: User texture binding. Use 'WGPUTextureView' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+// [ ] Renderer: Multi-viewport support (multiple windows). Not meaningful on the web.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/backends/imgui_impl_win32.cpp b/backends/imgui_impl_win32.cpp
index 0e48d86..8160035 100644
--- a/backends/imgui_impl_win32.cpp
+++ b/backends/imgui_impl_win32.cpp
@@ -7,6 +7,7 @@
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy VK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
@@ -21,6 +22,7 @@
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
+// 2024-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
// 2024-07-08: Inputs: Fixed ImGuiMod_Super being mapped to VK_APPS instead of VK_LWIN||VK_RWIN. (#7768)
// 2023-10-05: Inputs: Added support for extra ImGuiKey values: F13 to F24 function keys, app back/forward keys.
// 2023-09-25: Inputs: Synthesize key-down event on key-up for VK_SNAPSHOT / ImGuiKey_PrintScreen as Windows doesn't emit it (same behavior as GLFW/SDL).
@@ -103,6 +105,11 @@
#pragma GCC diagnostic ignored "-Wcast-function-type" // warning: cast between incompatible function types (for loader)
#endif
+// Forward Declarations
+static void ImGui_ImplWin32_InitPlatformInterface(bool platform_has_own_dc);
+static void ImGui_ImplWin32_ShutdownPlatformInterface();
+static void ImGui_ImplWin32_UpdateMonitors();
+
struct ImGui_ImplWin32_Data
{
HWND hWnd;
@@ -113,6 +120,7 @@
INT64 TicksPerSecond;
ImGuiMouseCursor LastMouseCursor;
UINT32 KeyboardCodePage;
+ bool WantUpdateMonitors;
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
bool HasGamepad;
@@ -163,17 +171,21 @@
io.BackendPlatformName = "imgui_impl_win32";
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
+ io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional)
+ io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can call io.AddMouseViewportEvent() with correct data (optional)
bd->hWnd = (HWND)hwnd;
+ bd->WantUpdateMonitors = true;
bd->TicksPerSecond = perf_frequency;
bd->Time = perf_counter;
bd->LastMouseCursor = ImGuiMouseCursor_COUNT;
ImGui_ImplWin32_UpdateKeyboardCodePage();
- // Set platform dependent data in viewport
+ // Our mouse update function expect PlatformHandle to be filled for the main viewport
ImGuiViewport* main_viewport = ImGui::GetMainViewport();
main_viewport->PlatformHandle = main_viewport->PlatformHandleRaw = (void*)bd->hWnd;
- IM_UNUSED(platform_has_own_dc); // Used in 'docking' branch
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ ImGui_ImplWin32_InitPlatformInterface(platform_has_own_dc);
// Dynamically load XInput library
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
@@ -216,6 +228,8 @@
IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
+ ImGui_ImplWin32_ShutdownPlatformInterface();
+
// Unload XInput library
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
if (bd->XInputDLL)
@@ -224,7 +238,7 @@
io.BackendPlatformName = nullptr;
io.BackendPlatformUserData = nullptr;
- io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad);
+ io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_HasMouseHoveredViewport);
IM_DELETE(bd);
}
@@ -298,33 +312,59 @@
io.AddKeyEvent(ImGuiMod_Super, IsVkDown(VK_LWIN) || IsVkDown(VK_RWIN));
}
+// This code supports multi-viewports (multiple OS Windows mapped into different Dear ImGui viewports)
+// Because of that, it is a little more complicated than your typical single-viewport binding code!
static void ImGui_ImplWin32_UpdateMouseData()
{
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(bd->hWnd != 0);
+ POINT mouse_screen_pos;
+ bool has_mouse_screen_pos = ::GetCursorPos(&mouse_screen_pos) != 0;
+
HWND focused_window = ::GetForegroundWindow();
- const bool is_app_focused = (focused_window == bd->hWnd);
+ const bool is_app_focused = (focused_window && (focused_window == bd->hWnd || ::IsChild(focused_window, bd->hWnd) || ImGui::FindViewportByPlatformHandle((void*)focused_window)));
if (is_app_focused)
{
// (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)
{
POINT pos = { (int)io.MousePos.x, (int)io.MousePos.y };
- if (::ClientToScreen(bd->hWnd, &pos))
- ::SetCursorPos(pos.x, pos.y);
+ if ((io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) == 0)
+ ::ClientToScreen(focused_window, &pos);
+ ::SetCursorPos(pos.x, pos.y);
}
// (Optional) Fallback to provide mouse position when focused (WM_MOUSEMOVE already provides this when hovered or captured)
// This also fills a short gap when clicking non-client area: WM_NCMOUSELEAVE -> modal OS move -> gap -> WM_NCMOUSEMOVE
- if (!io.WantSetMousePos && bd->MouseTrackedArea == 0)
+ if (!io.WantSetMousePos && bd->MouseTrackedArea == 0 && has_mouse_screen_pos)
{
- POINT pos;
- if (::GetCursorPos(&pos) && ::ScreenToClient(bd->hWnd, &pos))
- io.AddMousePosEvent((float)pos.x, (float)pos.y);
+ // 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)
+ // (This is the position you can get with ::GetCursorPos() + ::ScreenToClient() or WM_MOUSEMOVE.)
+ // 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)
+ // (This is the position you can get with ::GetCursorPos() or WM_MOUSEMOVE + ::ClientToScreen(). In theory adding viewport->Pos to a client position would also be the same.)
+ POINT mouse_pos = mouse_screen_pos;
+ if (!(io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable))
+ ::ScreenToClient(bd->hWnd, &mouse_pos);
+ io.AddMousePosEvent((float)mouse_pos.x, (float)mouse_pos.y);
}
}
+
+ // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
+ // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
+ // - [X] Win32 backend correctly ignore viewports with the _NoInputs flag (here using ::WindowFromPoint with WM_NCHITTEST + HTTRANSPARENT in WndProc does that)
+ // 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] Win32 backend correctly reports this regardless of another viewport behind focused and dragged from (we need this to find a useful drag and drop target).
+ ImGuiID mouse_viewport_id = 0;
+ if (has_mouse_screen_pos)
+ if (HWND hovered_hwnd = ::WindowFromPoint(mouse_screen_pos))
+ if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle((void*)hovered_hwnd))
+ mouse_viewport_id = viewport->ID;
+ io.AddMouseViewportEvent(mouse_viewport_id);
}
// Gamepad navigation mapping
@@ -384,6 +424,37 @@
#endif // #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
}
+static BOOL CALLBACK ImGui_ImplWin32_UpdateMonitors_EnumFunc(HMONITOR monitor, HDC, LPRECT, LPARAM)
+{
+ MONITORINFO info = {};
+ info.cbSize = sizeof(MONITORINFO);
+ if (!::GetMonitorInfo(monitor, &info))
+ return TRUE;
+ ImGuiPlatformMonitor imgui_monitor;
+ imgui_monitor.MainPos = ImVec2((float)info.rcMonitor.left, (float)info.rcMonitor.top);
+ imgui_monitor.MainSize = ImVec2((float)(info.rcMonitor.right - info.rcMonitor.left), (float)(info.rcMonitor.bottom - info.rcMonitor.top));
+ imgui_monitor.WorkPos = ImVec2((float)info.rcWork.left, (float)info.rcWork.top);
+ imgui_monitor.WorkSize = ImVec2((float)(info.rcWork.right - info.rcWork.left), (float)(info.rcWork.bottom - info.rcWork.top));
+ imgui_monitor.DpiScale = ImGui_ImplWin32_GetDpiScaleForMonitor(monitor);
+ imgui_monitor.PlatformHandle = (void*)monitor;
+ if (imgui_monitor.DpiScale <= 0.0f)
+ return TRUE; // Some accessibility applications are declaring virtual monitors with a DPI of 0, see #7902.
+ ImGuiPlatformIO& io = ImGui::GetPlatformIO();
+ if (info.dwFlags & MONITORINFOF_PRIMARY)
+ io.Monitors.push_front(imgui_monitor);
+ else
+ io.Monitors.push_back(imgui_monitor);
+ return TRUE;
+}
+
+static void ImGui_ImplWin32_UpdateMonitors()
+{
+ ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
+ ImGui::GetPlatformIO().Monitors.resize(0);
+ ::EnumDisplayMonitors(nullptr, nullptr, ImGui_ImplWin32_UpdateMonitors_EnumFunc, 0);
+ bd->WantUpdateMonitors = false;
+}
+
void ImGui_ImplWin32_NewFrame()
{
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
@@ -394,6 +465,8 @@
RECT rect = { 0, 0, 0, 0 };
::GetClientRect(bd->hWnd, &rect);
io.DisplaySize = ImVec2((float)(rect.right - rect.left), (float)(rect.bottom - rect.top));
+ if (bd->WantUpdateMonitors)
+ ImGui_ImplWin32_UpdateMonitors();
// Setup time step
INT64 current_time = 0;
@@ -610,8 +683,11 @@
bd->MouseTrackedArea = area;
}
POINT mouse_pos = { (LONG)GET_X_LPARAM(lParam), (LONG)GET_Y_LPARAM(lParam) };
- if (msg == WM_NCMOUSEMOVE && ::ScreenToClient(hwnd, &mouse_pos) == FALSE) // WM_NCMOUSEMOVE are provided in absolute coordinates.
- return 0;
+ bool want_absolute_pos = (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0;
+ if (msg == WM_MOUSEMOVE && want_absolute_pos) // WM_MOUSEMOVE are client-relative coordinates.
+ ::ClientToScreen(hwnd, &mouse_pos);
+ if (msg == WM_NCMOUSEMOVE && !want_absolute_pos) // WM_NCMOUSEMOVE are absolute coordinates.
+ ::ScreenToClient(hwnd, &mouse_pos);
io.AddMouseSourceEvent(mouse_source);
io.AddMousePosEvent((float)mouse_pos.x, (float)mouse_pos.y);
return 0;
@@ -750,6 +826,9 @@
bd->WantUpdateHasGamepad = true;
#endif
return 0;
+ case WM_DISPLAYCHANGE:
+ bd->WantUpdateMonitors = true;
+ return 0;
}
return 0;
}
@@ -814,6 +893,10 @@
// Helper function to enable DPI awareness without setting up a manifest
void ImGui_ImplWin32_EnableDpiAwareness()
{
+ // Make sure monitors will be updated with latest correct scaling
+ if (ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData())
+ bd->WantUpdateMonitors = true;
+
if (_IsWindows10OrGreater())
{
static HINSTANCE user32_dll = ::LoadLibraryA("user32.dll"); // Reference counted per-process
@@ -914,6 +997,370 @@
}
//---------------------------------------------------------------------------------------------------------
+// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
+// This is an _advanced_ and _optional_ feature, allowing the backend to create and handle multiple viewports simultaneously.
+// 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..
+//--------------------------------------------------------------------------------------------------------
+
+// Helper structure we store in the void* RendererUserData field of each ImGuiViewport to easily retrieve our backend data.
+struct ImGui_ImplWin32_ViewportData
+{
+ HWND Hwnd;
+ HWND HwndParent;
+ bool HwndOwned;
+ DWORD DwStyle;
+ DWORD DwExStyle;
+
+ ImGui_ImplWin32_ViewportData() { Hwnd = HwndParent = nullptr; HwndOwned = false; DwStyle = DwExStyle = 0; }
+ ~ImGui_ImplWin32_ViewportData() { IM_ASSERT(Hwnd == nullptr); }
+};
+
+static void ImGui_ImplWin32_GetWin32StyleFromViewportFlags(ImGuiViewportFlags flags, DWORD* out_style, DWORD* out_ex_style)
+{
+ if (flags & ImGuiViewportFlags_NoDecoration)
+ *out_style = WS_POPUP;
+ else
+ *out_style = WS_OVERLAPPEDWINDOW;
+
+ if (flags & ImGuiViewportFlags_NoTaskBarIcon)
+ *out_ex_style = WS_EX_TOOLWINDOW;
+ else
+ *out_ex_style = WS_EX_APPWINDOW;
+
+ if (flags & ImGuiViewportFlags_TopMost)
+ *out_ex_style |= WS_EX_TOPMOST;
+}
+
+static HWND ImGui_ImplWin32_GetHwndFromViewportID(ImGuiID viewport_id)
+{
+ if (viewport_id != 0)
+ if (ImGuiViewport* viewport = ImGui::FindViewportByID(viewport_id))
+ return (HWND)viewport->PlatformHandle;
+ return nullptr;
+}
+
+static void ImGui_ImplWin32_CreateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = IM_NEW(ImGui_ImplWin32_ViewportData)();
+ viewport->PlatformUserData = vd;
+
+ // Select style and parent window
+ ImGui_ImplWin32_GetWin32StyleFromViewportFlags(viewport->Flags, &vd->DwStyle, &vd->DwExStyle);
+ vd->HwndParent = ImGui_ImplWin32_GetHwndFromViewportID(viewport->ParentViewportId);
+
+ // Create window
+ RECT rect = { (LONG)viewport->Pos.x, (LONG)viewport->Pos.y, (LONG)(viewport->Pos.x + viewport->Size.x), (LONG)(viewport->Pos.y + viewport->Size.y) };
+ ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle);
+ vd->Hwnd = ::CreateWindowEx(
+ vd->DwExStyle, _T("ImGui Platform"), _T("Untitled"), vd->DwStyle, // Style, class name, window name
+ rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, // Window area
+ vd->HwndParent, nullptr, ::GetModuleHandle(nullptr), nullptr); // Owner window, Menu, Instance, Param
+ vd->HwndOwned = true;
+ viewport->PlatformRequestResize = false;
+ viewport->PlatformHandle = viewport->PlatformHandleRaw = vd->Hwnd;
+
+ // Secondary viewports store their imgui context
+ ::SetPropA(vd->Hwnd, "IMGUI_CONTEXT", ImGui::GetCurrentContext());
+}
+
+static void ImGui_ImplWin32_DestroyWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
+ if (ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData)
+ {
+ if (::GetCapture() == vd->Hwnd)
+ {
+ // Transfer capture so if we started dragging from a window that later disappears, we'll still receive the MOUSEUP event.
+ ::ReleaseCapture();
+ ::SetCapture(bd->hWnd);
+ }
+ if (vd->Hwnd && vd->HwndOwned)
+ ::DestroyWindow(vd->Hwnd);
+ vd->Hwnd = nullptr;
+ IM_DELETE(vd);
+ }
+ viewport->PlatformUserData = viewport->PlatformHandle = nullptr;
+}
+
+static void ImGui_ImplWin32_ShowWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+
+ // ShowParent() also brings parent to front, which is not always desirable,
+ // so we temporarily disable parenting. (#7354)
+ if (vd->HwndParent != NULL)
+ ::SetWindowLongPtr(vd->Hwnd, GWLP_HWNDPARENT, (LONG_PTR)nullptr);
+
+ if (viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing)
+ ::ShowWindow(vd->Hwnd, SW_SHOWNA);
+ else
+ ::ShowWindow(vd->Hwnd, SW_SHOW);
+
+ // Restore
+ if (vd->HwndParent != NULL)
+ ::SetWindowLongPtr(vd->Hwnd, GWLP_HWNDPARENT, (LONG_PTR)vd->HwndParent);
+}
+
+static void ImGui_ImplWin32_UpdateWindow(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+
+ // Update Win32 parent if it changed _after_ creation
+ // Unlike style settings derived from configuration flags, this is more likely to change for advanced apps that are manipulating ParentViewportID manually.
+ HWND new_parent = ImGui_ImplWin32_GetHwndFromViewportID(viewport->ParentViewportId);
+ if (new_parent != vd->HwndParent)
+ {
+ // Win32 windows can either have a "Parent" (for WS_CHILD window) or an "Owner" (which among other thing keeps window above its owner).
+ // Our Dear Imgui-side concept of parenting only mostly care about what Win32 call "Owner".
+ // The parent parameter of CreateWindowEx() sets up Parent OR Owner depending on WS_CHILD flag. In our case an Owner as we never use WS_CHILD.
+ // Calling ::SetParent() here would be incorrect: it will create a full child relation, alter coordinate system and clipping.
+ // Calling ::SetWindowLongPtr() with GWLP_HWNDPARENT seems correct although poorly documented.
+ // https://devblogs.microsoft.com/oldnewthing/20100315-00/?p=14613
+ vd->HwndParent = new_parent;
+ ::SetWindowLongPtr(vd->Hwnd, GWLP_HWNDPARENT, (LONG_PTR)vd->HwndParent);
+ }
+
+ // (Optional) Update Win32 style if it changed _after_ creation.
+ // Generally they won't change unless configuration flags are changed, but advanced uses (such as manually rewriting viewport flags) make this useful.
+ DWORD new_style;
+ DWORD new_ex_style;
+ ImGui_ImplWin32_GetWin32StyleFromViewportFlags(viewport->Flags, &new_style, &new_ex_style);
+
+ // Only reapply the flags that have been changed from our point of view (as other flags are being modified by Windows)
+ if (vd->DwStyle != new_style || vd->DwExStyle != new_ex_style)
+ {
+ // (Optional) Update TopMost state if it changed _after_ creation
+ bool top_most_changed = (vd->DwExStyle & WS_EX_TOPMOST) != (new_ex_style & WS_EX_TOPMOST);
+ HWND insert_after = top_most_changed ? ((viewport->Flags & ImGuiViewportFlags_TopMost) ? HWND_TOPMOST : HWND_NOTOPMOST) : 0;
+ UINT swp_flag = top_most_changed ? 0 : SWP_NOZORDER;
+
+ // Apply flags and position (since it is affected by flags)
+ vd->DwStyle = new_style;
+ vd->DwExStyle = new_ex_style;
+ ::SetWindowLong(vd->Hwnd, GWL_STYLE, vd->DwStyle);
+ ::SetWindowLong(vd->Hwnd, GWL_EXSTYLE, vd->DwExStyle);
+ RECT rect = { (LONG)viewport->Pos.x, (LONG)viewport->Pos.y, (LONG)(viewport->Pos.x + viewport->Size.x), (LONG)(viewport->Pos.y + viewport->Size.y) };
+ ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle); // Client to Screen
+ ::SetWindowPos(vd->Hwnd, insert_after, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, swp_flag | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+ ::ShowWindow(vd->Hwnd, SW_SHOWNA); // This is necessary when we alter the style
+ viewport->PlatformRequestMove = viewport->PlatformRequestResize = true;
+ }
+}
+
+static ImVec2 ImGui_ImplWin32_GetWindowPos(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ POINT pos = { 0, 0 };
+ ::ClientToScreen(vd->Hwnd, &pos);
+ return ImVec2((float)pos.x, (float)pos.y);
+}
+
+static void ImGui_ImplWin32_SetWindowPos(ImGuiViewport* viewport, ImVec2 pos)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ RECT rect = { (LONG)pos.x, (LONG)pos.y, (LONG)pos.x, (LONG)pos.y };
+ ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle);
+ ::SetWindowPos(vd->Hwnd, nullptr, rect.left, rect.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
+}
+
+static ImVec2 ImGui_ImplWin32_GetWindowSize(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ RECT rect;
+ ::GetClientRect(vd->Hwnd, &rect);
+ return ImVec2(float(rect.right - rect.left), float(rect.bottom - rect.top));
+}
+
+static void ImGui_ImplWin32_SetWindowSize(ImGuiViewport* viewport, ImVec2 size)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ RECT rect = { 0, 0, (LONG)size.x, (LONG)size.y };
+ ::AdjustWindowRectEx(&rect, vd->DwStyle, FALSE, vd->DwExStyle); // Client to Screen
+ ::SetWindowPos(vd->Hwnd, nullptr, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
+}
+
+static void ImGui_ImplWin32_SetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ ::BringWindowToTop(vd->Hwnd);
+ ::SetForegroundWindow(vd->Hwnd);
+ ::SetFocus(vd->Hwnd);
+}
+
+static bool ImGui_ImplWin32_GetWindowFocus(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ return ::GetForegroundWindow() == vd->Hwnd;
+}
+
+static bool ImGui_ImplWin32_GetWindowMinimized(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ return ::IsIconic(vd->Hwnd) != 0;
+}
+
+static void ImGui_ImplWin32_SetWindowTitle(ImGuiViewport* viewport, const char* title)
+{
+ // ::SetWindowTextA() doesn't properly handle UTF-8 so we explicitely convert our string.
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ int n = ::MultiByteToWideChar(CP_UTF8, 0, title, -1, nullptr, 0);
+ ImVector<wchar_t> title_w;
+ title_w.resize(n);
+ ::MultiByteToWideChar(CP_UTF8, 0, title, -1, title_w.Data, n);
+ ::SetWindowTextW(vd->Hwnd, title_w.Data);
+}
+
+static void ImGui_ImplWin32_SetWindowAlpha(ImGuiViewport* viewport, float alpha)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ IM_ASSERT(alpha >= 0.0f && alpha <= 1.0f);
+ if (alpha < 1.0f)
+ {
+ DWORD style = ::GetWindowLongW(vd->Hwnd, GWL_EXSTYLE) | WS_EX_LAYERED;
+ ::SetWindowLongW(vd->Hwnd, GWL_EXSTYLE, style);
+ ::SetLayeredWindowAttributes(vd->Hwnd, 0, (BYTE)(255 * alpha), LWA_ALPHA);
+ }
+ else
+ {
+ DWORD style = ::GetWindowLongW(vd->Hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED;
+ ::SetWindowLongW(vd->Hwnd, GWL_EXSTYLE, style);
+ }
+}
+
+static float ImGui_ImplWin32_GetWindowDpiScale(ImGuiViewport* viewport)
+{
+ ImGui_ImplWin32_ViewportData* vd = (ImGui_ImplWin32_ViewportData*)viewport->PlatformUserData;
+ IM_ASSERT(vd->Hwnd != 0);
+ return ImGui_ImplWin32_GetDpiScaleForHwnd(vd->Hwnd);
+}
+
+// FIXME-DPI: Testing DPI related ideas
+static void ImGui_ImplWin32_OnChangedViewport(ImGuiViewport* viewport)
+{
+ (void)viewport;
+#if 0
+ ImGuiStyle default_style;
+ //default_style.WindowPadding = ImVec2(0, 0);
+ //default_style.WindowBorderSize = 0.0f;
+ //default_style.ItemSpacing.y = 3.0f;
+ //default_style.FramePadding = ImVec2(0, 0);
+ default_style.ScaleAllSizes(viewport->DpiScale);
+ ImGuiStyle& style = ImGui::GetStyle();
+ style = default_style;
+#endif
+}
+
+static LRESULT CALLBACK ImGui_ImplWin32_WndProcHandler_PlatformWindow(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ // Allow secondary viewport WndProc to be called regardless of current context
+ ImGuiContext* hwnd_ctx = (ImGuiContext*)::GetPropA(hWnd, "IMGUI_CONTEXT");
+ ImGuiContext* prev_ctx = ImGui::GetCurrentContext();
+ if (hwnd_ctx != prev_ctx && hwnd_ctx != NULL)
+ ImGui::SetCurrentContext(hwnd_ctx);
+
+ LRESULT result = 0;
+ if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
+ result = true;
+ else if (ImGuiViewport* viewport = ImGui::FindViewportByPlatformHandle((void*)hWnd))
+ {
+ switch (msg)
+ {
+ case WM_CLOSE:
+ viewport->PlatformRequestClose = true;
+ break;
+ case WM_MOVE:
+ viewport->PlatformRequestMove = true;
+ break;
+ case WM_SIZE:
+ viewport->PlatformRequestResize = true;
+ break;
+ case WM_MOUSEACTIVATE:
+ if (viewport->Flags & ImGuiViewportFlags_NoFocusOnClick)
+ result = MA_NOACTIVATE;
+ break;
+ case WM_NCHITTEST:
+ // Let mouse pass-through the window. This will allow the backend to call io.AddMouseViewportEvent() correctly. (which is optional).
+ // 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
+ // your main loop after calling UpdatePlatformWindows(). Iterate all viewports/platform windows and pass the flag to your windowing system.
+ if (viewport->Flags & ImGuiViewportFlags_NoInputs)
+ result = HTTRANSPARENT;
+ break;
+ }
+ }
+ if (result == 0)
+ result = DefWindowProc(hWnd, msg, wParam, lParam);
+ if (hwnd_ctx != prev_ctx && hwnd_ctx != NULL)
+ ImGui::SetCurrentContext(prev_ctx);
+ return result;
+}
+
+static void ImGui_ImplWin32_InitPlatformInterface(bool platform_has_own_dc)
+{
+ WNDCLASSEX wcex;
+ wcex.cbSize = sizeof(WNDCLASSEX);
+ wcex.style = CS_HREDRAW | CS_VREDRAW | (platform_has_own_dc ? CS_OWNDC : 0);
+ wcex.lpfnWndProc = ImGui_ImplWin32_WndProcHandler_PlatformWindow;
+ wcex.cbClsExtra = 0;
+ wcex.cbWndExtra = 0;
+ wcex.hInstance = ::GetModuleHandle(nullptr);
+ wcex.hIcon = nullptr;
+ wcex.hCursor = nullptr;
+ wcex.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
+ wcex.lpszMenuName = nullptr;
+ wcex.lpszClassName = _T("ImGui Platform");
+ wcex.hIconSm = nullptr;
+ ::RegisterClassEx(&wcex);
+
+ ImGui_ImplWin32_UpdateMonitors();
+
+ // Register platform interface (will be coupled with a renderer interface)
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ platform_io.Platform_CreateWindow = ImGui_ImplWin32_CreateWindow;
+ platform_io.Platform_DestroyWindow = ImGui_ImplWin32_DestroyWindow;
+ platform_io.Platform_ShowWindow = ImGui_ImplWin32_ShowWindow;
+ platform_io.Platform_SetWindowPos = ImGui_ImplWin32_SetWindowPos;
+ platform_io.Platform_GetWindowPos = ImGui_ImplWin32_GetWindowPos;
+ platform_io.Platform_SetWindowSize = ImGui_ImplWin32_SetWindowSize;
+ platform_io.Platform_GetWindowSize = ImGui_ImplWin32_GetWindowSize;
+ platform_io.Platform_SetWindowFocus = ImGui_ImplWin32_SetWindowFocus;
+ platform_io.Platform_GetWindowFocus = ImGui_ImplWin32_GetWindowFocus;
+ platform_io.Platform_GetWindowMinimized = ImGui_ImplWin32_GetWindowMinimized;
+ platform_io.Platform_SetWindowTitle = ImGui_ImplWin32_SetWindowTitle;
+ platform_io.Platform_SetWindowAlpha = ImGui_ImplWin32_SetWindowAlpha;
+ platform_io.Platform_UpdateWindow = ImGui_ImplWin32_UpdateWindow;
+ platform_io.Platform_GetWindowDpiScale = ImGui_ImplWin32_GetWindowDpiScale; // FIXME-DPI
+ platform_io.Platform_OnChangedViewport = ImGui_ImplWin32_OnChangedViewport; // FIXME-DPI
+
+ // Register main window handle (which is owned by the main application, not by us)
+ // 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.
+ ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
+ ImGui_ImplWin32_ViewportData* vd = IM_NEW(ImGui_ImplWin32_ViewportData)();
+ vd->Hwnd = bd->hWnd;
+ vd->HwndOwned = false;
+ main_viewport->PlatformUserData = vd;
+ main_viewport->PlatformHandle = (void*)bd->hWnd;
+}
+
+static void ImGui_ImplWin32_ShutdownPlatformInterface()
+{
+ ::UnregisterClass(_T("ImGui Platform"), ::GetModuleHandle(nullptr));
+ ImGui::DestroyPlatformWindows();
+}
+
+//---------------------------------------------------------------------------------------------------------
#if defined(__GNUC__)
#pragma GCC diagnostic pop
diff --git a/backends/imgui_impl_win32.h b/backends/imgui_impl_win32.h
index 3ad1a7e..4cf54d8 100644
--- a/backends/imgui_impl_win32.h
+++ b/backends/imgui_impl_win32.h
@@ -7,6 +7,7 @@
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy VK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
diff --git a/docs/CHANGELOG.txt b/docs/CHANGELOG.txt
index d7fec4c..934925f 100644
--- a/docs/CHANGELOG.txt
+++ b/docs/CHANGELOG.txt
@@ -118,6 +118,16 @@
to handle minimization without burning CPU or GPU by running unthrottled code. (#7844)
- Examples: SDL3: Update for API changes: SDL_Init() returns 0 on failure.
+Docking+Viewports Branch:
+
+- Viewports: added optional platform_io.Platform_GetWindowWorkAreaInsets() hook
+ to allow backends to alter the default per-viewport work-area. (#7823)
+- Backends: don't report monitors with DpiScale of 0, which seemed to be reported for
+ virtual monitors instead by accessibility drivers. (#7902) [@nicolasnoble, @ocornut]
+- Backends: SDL2, SDL3: using SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN to support the
+ ImGuiViewportFlags_NoFocusOnAppearing flag, instead of using a Win32-specific hack.
+ (#7896) [@RT2Code]
+
-----------------------------------------------------------------------
VERSION 1.91.0 (Released 2024-07-30)
-----------------------------------------------------------------------
@@ -277,6 +287,16 @@
- Backends: GLFW+Emscripten: Fixed Emscripten warning when using mouse wheel on some setups
"Unable to preventDefault inside passive event listener". (#7647, #7600) [@ypujante]
+Docking+Viewports Branch:
+
+- Viewports: Always update fallback monitor to primary monitor if there's one.
+- Backends: OSX: Fixed NSAppKitVersion version limit for setWantsBestResolutionOpenGLSurface
+ usage. (#7814) [@YGXXD]
+- Backends: SDL3: Fixed a bug preventing ImGuiViewportFlags_NoFocusOnAppearing support from
+ working (Windows only).
+- Backends: Vulkan: ImGui_ImplVulkan_SwapBuffers() used by secondary viewports still proceeds
+ increasing frame counters on VK_SUBOPTIMAL_KHR. (#7825, #3881) [@NostraMagister]
+
-----------------------------------------------------------------------
VERSION 1.90.9 (Released 2024-07-01)
@@ -357,6 +377,19 @@
returning VK_SUBOPTIMAL_KHR, which doesn't seem to happen on Wayland. (#7671)
[@AndreiNego, @ocornut]
+Docking+Viewports Branch:
+
+- Windows, Menus: Fixed an issue where the size of sub-menu in their own viewport
+ would be erroneously clamped to the size of main viewport. (#7730)
+- Merged GetBackgroundDrawList() and GetBackgroundDrawList(ImGuiViewport* viewport)
+ api entry points into a same one GetBackgroundDrawList(ImGuiViewport* viewport = NULL);
+- Merged GetForegroundDrawList() and GetForegroundDrawList(ImGuiViewport* viewport)
+ api entry points into a same one GetForegroundDrawList(ImGuiViewport* viewport = NULL);
+- Backends: SDL3: Update for introduction of SDL_GLContext from void*. (#7701, #7702)
+ [@bcsanches]
+- Backends: Win32: Secondary viewports WndProc handler retrieve/set imgui context from
+ the HWND, allowing WndProc dispatch to work in multi-context setups.
+
-----------------------------------------------------------------------
VERSION 1.90.8 (Released 2024-06-06)
@@ -507,6 +540,15 @@
those API public. Only past users of imgui_internal.h with the extra parameters will be affected.
Added asserts for valid flags in various functions to detect _some_ misuses, BUT NOT ALL.
+Docking+Viewports Branch:
+
+- Docking: *BREAKING* changed signature of DockSpaceOverViewport() to allow passing
+ an explicit dockspace id if desired. (#7611)
+ Before: DockSpaceOverViewport(const ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, ...);
+ After: DockSpaceOverViewport(ImGuiID dockspace_id = 0, const ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, ...);
+ Simply add a leading 0 to your existing calls to DockSpaceOverViewport() if you have any.
+- Tables: resizing border hit-rect scales according to current monitor dpi scale.
+
-----------------------------------------------------------------------
VERSION 1.90.6 (Released 2024-05-08)
@@ -565,6 +607,18 @@
- Examples: GLFW+WebGPU: Added support for WebGPU-native/Dawn (#7435, #7132) [@eliasdaler, @Zelif]
- Examples: GLFW+WebGPU: Renamed example_emscripten_wgpu/ to example_glfw_wgpu/. (#7435, #7132)
+Docking+Viewports Branch:
+
+- Docking: when io.ConfigDockingWithShift is enabled, fixed help tooltip erroneously
+ reading SetNextWindowXXX() data. (#6709, #4643, #7491) [@ocornut, @cfillion]
+- Viewports: fixed outer-right edge of MenuBar clipping rectangle off by one when window
+ is located on a monitor with negative coordinates. (#6861, #2884) [@cfillion]
+- Backends: Vulkan: reworked swap-chain resize handling for secondary viewports, fix for
+ typical Linux setups. (#2626, #3390, #3758, #7508, #7513) [@RoryO, @InsideBSITheSecond]
+- Backends: Vulkan: create a custom pipeline for secondary viewports. Fixes issues
+ when user created main viewport uses a different renderpass. (#6325, #6305, #7398,
+ #3459, #3253, #3522) [@skaman, @FunMiles]
+
-----------------------------------------------------------------------
VERSION 1.90.5 (Released 2024-04-11)
@@ -621,6 +675,11 @@
Adding a link to the crawlable version, even though it is not intended for humans,
to increase its search rank.
+Docking+Viewports Branch:
+
+- Backends: Win32: made it so that an appearing viewport showing up doesn't bring
+ its parent to front. (#7354)
+
-----------------------------------------------------------------------
VERSION 1.90.4 (Released 2024-02-22)
@@ -654,6 +713,13 @@
- Demo: Custom Rendering: better demonstrate PathArcTo(), PathBezierQuadraticCurveTo(),
PathBezierCubicCurveTo(), PathStroke(), PathFillConvex() functions.
+Docking+Viewports Branch:
+
+- Backends: GLFW: enable ImGuiBackendFlags_HasMouseHoveredViewport support with GLFW 3.3.x,
+ as required specs for it was relaxed in 1.87. This enable better viewport hovering detection
+ without GLFW 3.4's GLFW_MOUSE_PASSTHROUGH, with less reliance on dear imgui's own heuristic
+ of platform windows order. (#7316)
+
-----------------------------------------------------------------------
VERSION 1.90.3 (Released 2024-02-14)
@@ -742,6 +808,18 @@
Often requested in some form (#6962, #5219, #3290, #4627, #5054, #3878, #2881, #1506, #1216, #968),
and useful for interactive completion/suggestions popups (#2057, #718)
+Docking+Viewports Branch:
+
+- Added ImGuiWindowClass::FocusRouteParentWindowId as a way to connect the focus route between
+ a tool window to a parent document window, so that Shortcuts in the documents are routed when the
+ tool is focused (regardless of whether the tool is docked or in a floating viewport, etc.) (#6798)
+- Added ImGuiDockNodeFlags_DockedWindowsInFocusRoute to automatically make a dockspace connect
+ the focus route of its docked window. This is provided a convenience in case you have windows
+ where a connection is not explicit. (#6798)
+- Viewports: Fixed moving accross monitors when io.ConfigWindowsMoveFromTitleBarOnly is set. (#7299, #3071)
+- Backends: OSX: Fixed not submitting Monitors info when viewports are not enabled, leading to
+ missing e.g. DpiScale info. (#7257) [@actboy168]
+
-----------------------------------------------------------------------
VERSION 1.90.1 (Released 2024-01-10)
@@ -846,6 +924,15 @@
(#6751) [@Traveller23, @ypujante]
- Examples: SDL3: Minor fixes following recent SDL3 in-progress development.
+Docking+Viewports Branch:
+
+- Windows: Fixed ImGuiCol_TitleBg/Active alpha being used for viewport-owned windows. (#7181) [@PathogenDavid]
+- Backends: DX12: Changed swapchain scaling mode to DXGI_SCALING_NONE to reduce artifacts as
+ queued frames aren't synchronized with platform window resizes. (#7152, #7153) [@SuperWangKai]
+- Backends: OSX: Fixed monitor and window position by correctly transforming Y origin on multi-viewports
+ multi-monitor setups. (#7028, #7101, #6009, #6432) [@dmirty-kuzmenko, @734vin]
+- Backends: OSX: Fixed IME position in multi-monitor multi-viewports setups. (#7028) [@734vin]
+
-----------------------------------------------------------------------
VERSION 1.90.0 (Released 2023-11-15)
@@ -1040,6 +1127,8 @@
Fixed leaks, and added ImGui_ImplVulkan_DestroyFontsTexture() (probably no need to call this directly).
(#6943, #6715, #6327, #3743, #4618)
[@helynranta, @thomasherzog, @guybrush77, @albin-johansson, @MiroKaku, @benbatya-fb, @ocornut]
+- Backends: Vulkan: use specified ColorAttachmentFormat when creating a secondary window when enabling
+ UseDynamicRendering option. (#6999, #5446, #5037) [@raaaviol]
- Backends: GLFW: Clear emscripten's MouseWheel callback before shutdown. (#6790, #6096, #4019) [@halx99]
- Backends: GLFW: Added support for F13 to F24 function keys. (#6891)
- Backends: SDL2, SDL3: Added support for F13 to F24 function keys, AppBack, AppForward. (#6891)
@@ -1057,6 +1146,31 @@
- Examples: GLFW+Vulkan, SDL+Vulkan: Simplified and removed code due to backend improvements.
- Internals: Renamed ImFloor() to ImTrunc(). Renamed ImFloorSigned() to ImFloor(). (#6861)
+Docking+Viewports Branch:
+
+- Viewports: Fixed window inner clipping rectangle off by one when window is located on a monitor
+ with negative coordinates. While it is expected that other small issues with arise from this
+ situation, at the moment we are fixing the most noticeable one. (#6861, #2884) [@Vuhdo, @alektron]
+- Docking: revised undocking to reduce accidental whole-node undocking:
+ - cannot undock a whole node by dragging from empty space in tab-bar.
+ - can undock whole node by dragging from window/collapse menu button.
+ - can undock single window by dragging from its tab.
+ - can still move (but not undock) whole node or whole hierarchy when node is part of a
+ floating hierarchy.
+ - added tooltip when hovering the collapse/window menu button, to faciliate understanding
+ that whole dock node may be undocked or grabbed from here.
+- Docking: Fixed an issue leading to incorrect restoration of selected tab in dock nodes that
+ don't carry the currently focused window. (#2304)
+- Docking: added ImGuiDockNodeFlags_NoUndocking. (#2999, #6823, #6780, #3492)
+- Docking: renamed ImGuiDockNodeFlags_NoSplit to ImGuiDockNodeFlags_NoDockingSplit.
+- Docking: renamed ImGuiDockNodeFlags_NoDockingInCentralNode to ImGuiDockNodeFlags_NoDockingOverCentralNode.
+- Docking: Internals: renamed ImGuiDockNodeFlags_NoDockingSplitMe to ImGuiDockNodeFlags_NoDockingSplit.
+- Docking: Fixed a bug where ClassId compare tests (when using SetNextWindowClass) on success would
+ prevent further filter from running, namely the one that prevent docking over a popup.
+- Backends: GLFW: Fixed an assertion in situation where the WndProc handler is different between
+ main and secondary viewport (may happen due to third-party hooks). (#6889)
+- Backends: DX9: Fixed incorrect assert triggering on reopening session with minimized windows. (#3424)
+
-----------------------------------------------------------------------
VERSION 1.89.9 (Released 2023-09-04)
@@ -1114,6 +1228,11 @@
- Examples: Emscripten+WebGPU: Fixed WGPUInstance creation process + use preferred
framebuffer format. (#6640, #6748) [@smileorigin]
+Docking+Viewports Branch:
+
+- Docking: when io.ConfigDockingWithShift is enabled, staying stationary while moving
+ a window displays an help tooltip to increase affordance. (#6709, #4643)
+
-----------------------------------------------------------------------
VERSION 1.89.8 (Released 2023-08-01)
@@ -1182,6 +1301,16 @@
- Examples: Vulkan: Creating minimal descriptor pools to fit only what is needed by
example. (#6642) [@SaschaWillem]
+Docking+Viewports Branch:
+
+- Docking, Style: resizing separators use same colors as window borders (ImGuiCol_Border)
+ for consistency. With default styles it doesn't make a big difference. (#2522) [@rmitton]
+ In the future if we promote using thick value for inner/outer docking padding we may
+ need to introduce new colors for it.
+- Docking: added style.DockingSeparatorSize, ImGuiStyleVar_DockingSeparatorSize. Now
+ also scaled by style.ScaleAllSizes(). (#3481, #4721, #2522) [@PossiblyAShrub, @wobbier]
+- Docking: fixed rendering of docked-window scrollbar above outer border. (#2522)
+
-----------------------------------------------------------------------
VERSION 1.89.7 (Released 2023-07-04)
@@ -1277,6 +1406,23 @@
- Examples: Win32+OpenGL3: Changed DefWindowProc() to DefWindowProcW() to match other examples
and support the example app being compiled without UNICODE. (#6516, #5725, #5961, #5975) [@yenixing]
+Docking+Viewports Branch:
+
+- Viewports+Docking: Fixed extraneous viewport+platform-window recreation in various
+ combination of showing or hiding windows, docking with/without split, undocking.
+ While with some backends and without OS decorations, some extraneous window recreation
+ were visibly not noticeable, they would typically become noticeable when enabling
+ OS decorations on those windows (e.g. Windows title bar fade-in/animation).
+- Viewports: Closing a viewport via OS/platform means (e.g. OS close button or task-bar menu),
+ mark all windows in this viewport as closed.
+- Docking: Fixed one-frame flickering on reappearing windows binding to a dock node
+ where a later-submitted window was already bound.
+- Docking: Fixed dragging from title-bar empty space (regression from 1.88 related to
+ keeping ID alive when calling low-level ButtonBehavior() directly). (#5181, #2645)
+- Docking: [Internal] DockBuilderDockWindow() API calls don't clear docking order
+ if the target node is same as existing one.
+- Backends: Win32: Added support for changing ParentViewportID after viewport creation.
+
-----------------------------------------------------------------------
VERSION 1.89.6 (Released 2023-05-31)
@@ -1346,6 +1492,23 @@
- Examples: Added SDL3+SDL_Renderer example. (#6286)
- Examples: Updated all Visual Studio projects and batches to use /utf-8 argument.
+Docking+Viewports Branch:
+
+- Viewports: Fixed platform-side focus (e.g. Alt+Tab) from leading to accidental
+ closure of Modal windows. Regression from 1.89.5. (#6357, #6299)
+- Viewports: Fixed loss of imgui-side focus when dragging a secondary viewport back in
+ main viewport, due to platform-side handling changes. Regression from 1.89.5 (#6299)
+- Viewports: Avoid applying imgui-side focus when focus change is due to a viewport
+ destruction. Fixes erroneous popup closure on closing a previous popup. (#6462, #6299)
+- Viewports: Added void* ImGuiPlatformMonitor::PlatformHandle field (backend-dependant),
+ for usage by user code.
+- Backends: GLFW: Preserve monitor list when there are no monitor, may briefly
+ happen when recovering from macOS sleeping mode. (#5683) [@Guistac]
+- Backends: SDL2: Update monitor list when receiving a display event. (#6348)
+ Note however that SDL2 currently doesn't have an event for a DPI/Scaling change,
+ so monitor data won't be updated in this situation.
+- Backends: SDL3: Update monitor list when receiving a display event. (#6348)
+
-----------------------------------------------------------------------
VERSION 1.89.5 (Released 2023-04-13)
@@ -1403,7 +1566,6 @@
is to other IME function such as SDL_SetTextInputRect(). (#6306, #6071, #1953)
- Backends: GLFW: Added support on Win32 only for io.AddMouseSourceEvent() to discriminate
Mouse/TouchScreen/Pen. (#2334, #2702)
-- Backends: GLFW: Fixed key modifiers handling on secondary viewports. (#6248, #6034) [@aiekick]
- Backends: Android: Added support for io.AddMouseSourceEvent() to discriminate Mouse/TouchScreen/Pen.
(#6315) [@PathogenDavid]
- Backends: OSX: Added support for io.AddMouseSourceEvent() to discriminate Mouse/Pen.
@@ -1419,6 +1581,16 @@
- TestSuite: Added variety of new regression tests and improved/amended existing ones
in imgui_test_engine/ repo. [@PathogenDavid, @ocornut]
+Docking+Viewports Branch:
+
+- Viewports: Setting focus from Platform/OS (e.g. via decoration, or Alt-Tab) sets corresponding
+ focus at Dear ImGui level (generally last focused window in the viewport). (#6299)
+- Docking: Fixed using GetItemXXX() or IsItemXXX() functions after a DockSpace(). (#6217)
+- Backends: GLFW: Fixed key modifiers handling on secondary viewports. (#6248, #6034) [@aiekick]
+- Backends: GLFW: Fixed Emscripten erroneously enabling multi-viewport support, leading to assert. (#5683)
+- Backends: SDL2/SDL3: Fixed IME text input rectangle position with viewports. (#6071, #1953)
+- Backends: SDL3: Fixed for compilation with multi-viewports. (#6255) [@P3RK4N]
+
-----------------------------------------------------------------------
VERSION 1.89.4 (Released 2023-03-14)
@@ -1493,7 +1665,6 @@
and ImGuiConfigFlags_NavEnableGamepad by default. (#787)
- Internals: Misc tweaks to facilitate applying an explicit-context patch. (#5856) [@Dragnalith]
-
-----------------------------------------------------------------------
VERSION 1.89.3 (Released 2023-02-14)
-----------------------------------------------------------------------
@@ -1594,6 +1765,10 @@
- Examples: SDL2+SDL_Renderer: Added call to SDL_RenderSetScale() to fix display on a
Retina display (albeit lower-res as our other unmodified examples). (#6121, #6065, #5931).
+Docking+Viewports Branch:
+
+- Backends: GLFW: Handle unsupported glfwGetVideoMode() for Emscripten. (#6096)
+
-----------------------------------------------------------------------
VERSION 1.89.2 (Released 2023-01-05)
@@ -1644,6 +1819,17 @@
- Backends: Vulkan: Fixed sampler passed to ImGui_ImplVulkan_AddTexture() not being honored as we were using
an immutable sampler. (#5502, #6001, #914) [@martin-ejdestig, @rytisss]
+Docking+Viewports Branch:
+
+- Docking: Internals: fixed DockBuilderCopyDockSpace() crashing when windows not in the
+ remapping list are docked on the left or top side of a split. (#6035)
+- Docking: fixed DockSpace() with ImGuiDockNodeFlags_KeepAliveOnly marking current window
+ as written to, even if it doesn't technically submit an item. This allow using KeepAliveOnly
+ from any window location. (#6037)
+- Backends: OSX: fixed typo in ImGui_ImplOSX_GetWindowSize that would cause issues when resiing
+ from OS decorations, if they are enabled on secondary viewports. (#6009) [@sivu]
+- Backends: Metal: fixed secondary viewport rendering. (#6015) [@dmirty-kuzmenko]
+
-----------------------------------------------------------------------
VERSION 1.89.1 (Released 2022-11-24)
@@ -1670,6 +1856,13 @@
- Backends: GLFW: cancel out errors emitted by glfwGetKeyName() when a name is missing. (#5908)
- Backends: WebGPU: fixed validation error with default depth buffer settings. (#5869, #5914) [@kdchambers]
+Docking+Viewports Branch:
+
+- Viewports: Fixed collapsed windows setting ImGuiViewportFlags_NoRendererClear without
+ making title bar color opaque, leading to potential texture/fb garbage being visible.
+ Right now as we don't fully support transparent viewports (#2766), so we turn that
+ 'TitleBgCollapsed' color opaque just lke we do for 'WindowBG' on uncollapsed windows.
+
-----------------------------------------------------------------------
VERSION 1.89 (Released 2022-11-15)
@@ -1861,6 +2054,23 @@
- Backends: Vulkan: Added experimental ImGui_ImplVulkan_RemoveTexture() for api symmetry. (#914, #5738).
- Backends: WebGPU: fixed rendering when a depth buffer is enabled. (#5869) [@brainlag]
+Docking+Viewports Branch:
+
+- Docking: Fixed incorrect focus highlight on docking node when focusing a menu. (#5702)
+- Docking, Nav: Fixed using gamepad/keyboard navigation not being able enter menu layer when
+ it only contained the standard Collapse/Close buttons and no actual menu. (#5463, #4792)
+- Docking: Fixed regression introduced in v1.87 when docked window content not rendered
+ while switching between with CTRL+Tab. [@rokups]
+- Docking: Fixed amending into an existing tab bar from rendering invisible items. (#5515)
+- Docking: Made spacing between dock nodes not a dropping gap. When hovering it only
+ outer-docking drop markers are visible.
+- Docking+Viewports: Fixed undocking window node causing parent viewports to become unresponsive
+ in certain situation (e.g. hidden tab bar). (#5503) [@rokups]
+- Backends: SDL: Fixed building backend under non-OSX Apple targets (e.g. iPhone). (#5665)
+- Backends: SDL: Fixed drag'n drop crossing a viewport border losing mouse coordinates. (#5710, #5012)
+- Backends: GLFW: Fixed leftover static variable preventing from changing or
+ reinitializing backend while application is running. (#4616, #5434) [@rtoumazet]
+
-----------------------------------------------------------------------
VERSION 1.88 (Released 2022-06-21)
@@ -1995,6 +2205,26 @@
- Examples: Emscripten+WebGPU: Fix building for latest WebGPU specs. (#3632)
- Examples: OSX+Metal, OSX+OpenGL: Removed now-unnecessary calls to ImGui_ImplOSX_HandleEvent(). (#4821)
+Docking+Viewports Branch:
+
+- Docking: Fixed floating docked nodes not being clamped into viewport workrect to stay reachable
+ when io.ConfigWindowsMoveFromTitleBarOnly is true and multi-viewports are disabled. (#5044)
+- Docking: Fixed a regression where moving window would be interrupted after undocking a tab
+ when io.ConfigDockingAlwaysTabBar is true. (#5324) [@rokups]
+- Docking: Fixed incorrect focus highlight on docking node when focusing empty central node
+ or a child window which was manually injected into a dockspace window.
+- Docking, Modal: Fixed a crash when opening popup from a parent which is being docked on the same frame. (#5401)
+- Viewports: Fixed an issue where MouseViewport was lagging by a frame when using 1.87 Input Queue.
+ A common side-effect would be that when releasing a window drag the underlying window would highlight
+ for a frame. (#5837, #4921) [@cfillion]
+- Viewports: Fixed translating a host viewport from briefly altering the size of AlwaysAutoResize windows. (#5057)
+- Viewports: Fixed main viewport size not matching ImDrawData::DisplaySize for one frame during resize
+ when multi-viewports are disabled. (#4900)
+- Backends: SDL: Fixed dragging out main viewport broken on some SDL setups. (#5012) [@rokups]
+- Backends: OSX: Added support for multi-viewports. [@stuartcarnie, @metarutaiga] (#4821, #2778)
+- Backends: Metal: Added support for multi-viewports. [@stuartcarnie, @metarutaiga] (#4821, #2778)
+- Examples: OSX+Metal, SDL+Metal, GLFW+Metal: Added support for multi-viewports. [@rokups]
+
-----------------------------------------------------------------------
VERSION 1.87 (Released 2022-02-07)
@@ -2137,6 +2367,29 @@
- Backends: WebGPU: Fixed incorrect size parameters in wgpuRenderPassEncoderSetIndexBuffer() and
wgpuRenderPassEncoderSetVertexBuffer() calls. (#4891) [@FeepsDev]
+Docking+Viewports Branch:
+
+- Docking: Fixed a CTRL+TAB crash when aiming at an empty docked window. (#4792)
+- Docking: Tabs use their own identifier instead of the Window identifier.
+ (This will invalidate some stored .ini data such as last selected tab, sorry!)
+- Docking: Fixed size constraints not working on single window holding on a dock id (still doesn't work on docked windows).
+- Docking: Fixed CTRL+TAB back into a docked window not selecting menu layer when no item are on main layer.
+- Viewports, IO: Added io.AddMouseViewportEvent() function to queue hovered viewport change (when known by backend).
+- Viewports: Relaxed specs for backend supporting ImGuiBackendFlags_HasMouseHoveredViewport: it is now _optional_
+ for the backend to have to ignore viewports with the _NoInputs flag when call io.AddMouseViewportEvent(). It is
+ much better if they can (Win32 and GLFW 3.3+ backends can, SDL and GLFW 3.2 backends cannot, they are lacking data).
+ A concrete example is: when dragging a viewport for docking, the viewport is marked with _NoInputs to allow us
+ to pick the target viewports for docking. If the backend reports a viewport with _NoInputs when calling the
+ io.AddMouseViewportEvent() function, then Dear ImGui will revert to its flawed heuristic to find the viewport under.
+ By lowering those specs, we allow the SDL and more backend to support this, only relying on the heuristic in a few
+ drag and drop situations rather that relying on it everywhere.
+- Viewports: Fixed a CTRL+TAB crash with viewports enabled when the window list needs to appears in
+ its own viewport (regression from 1.86). (#4023, #787)
+- Viewports: Fixed active InputText() from preventing viewports to merge. (#4212)
+- Backends: SDL: Added support for ImGuiBackendFlags_HasMouseHoveredViewport now that its specs have been lowered.
+- (Breaking) Removed ImGuiPlatformIO::Platform_SetImeInputPos() in favor of newly standardized
+ io.SetPlatformImeDataFn() function. Should not affect more than default backends.
+
-----------------------------------------------------------------------
VERSION 1.86 (Released 2021-12-22)
@@ -2235,6 +2488,24 @@
wgpuRenderPassEncoderSetIndexBuffer() functions as validation layers appears to not do what the
in-flux specs says. (#4766) [@meshula]
+Docking+Viewports Branch:
+
+- Docking: Revert removal of io.ConfigDockingWithShift config option (removed in 1.83). (#4643)
+- Docking: Fixed a bug undocking windows docked into a non-visible or _KeepAliveOnly dockspace
+ when unrelated windows submitted before the dockspace have dynamic visibility. (#4757)
+- Docking, Style: Docked windows honor ImGuiCol_WindowBg. (#2700, #2539)
+- Docking, Style: Docked windows honor display their border properly. (#2522)
+- Docking: Fixed incorrectly rounded tab bars for dock node that are not at the top of their dock tree.
+- Docking: Fixed single-frame node pos/size inconsistencies when window stop or start being submitted.
+- Docking: Prevent docking any window created above a popup/modal. (#4317)
+- Viewports: Made it possible to explicitly assign ImGuiWindowClass::ParentViewportId to 0 in order
+ to ensure a window is not parented. Previously this would use the global default (which might be 0,
+ but not always as it would depend on io.ConfigViewportsNoDefaultParent). (#3152, #2871)
+- Viewports: Fixed tooltip in own viewport over modal from being incorrectly dimmed. (#4729)
+- Viewports: Fixed CTRL+TAB highlight outline on docked windows not always fitting in host viewport.
+- Backends: Made it possible to shutdown default Platform Backends before the Renderer backends. (#4656)
+- Disabled: Fixed nested BeginDisabled()/EndDisabled() bug in Docking branch due to bad merge. (#4655, #4452, #4453, #4462)
+
-----------------------------------------------------------------------
VERSION 1.85 (Released 2021-10-12)
@@ -2253,6 +2524,10 @@
Can use 'GetWindowContentRegionMax().x - GetWindowContentRegionMin().x' instead but it's not
very useful in practice, and the only use of it in the demo was illfit.
Using 'GetContentRegionAvail().x' is generally a better choice.
+- (Docking branch) IsWindowFocused() and IsWindowHovered() with only the _ChildWindows flag
+ and without the _RootWindow flag used to leak docking hierarchy, so a docked window would
+ return as the child of the window hosting the dockspace. This was inconsistent and incorrect
+ with other behaviors so we fixed it. Added a new _DockHierarchy flag to opt-in this behavior.
Other Changes:
@@ -2326,6 +2601,29 @@
- Backends: All renderers: Normalize clipping rect handling across backends. (#4464)
- Examples: Added SDL + SDL_Renderer example in "examples/example_sdl_sdlrenderer/" folder. (#3926) [@1bsyl]
+Docking+Viewports Branch:
+
+- IsWindowFocused: Fixed using ImGuiFocusedFlags_ChildWindows (without _RootWindow) from leaking the
+ docking hierarchy. Added ImGuiFocusedFlags_DockHierarchy flag to consider docking hierarchy in the test.
+- IsWindowHovered: Fixed using ImGuiHoveredFlags_ChildWindows (without _RootWindow) from leaking the
+ docking hierarchy. Added ImGuiHoveredFlags_DockHierarchy flag to consider docking hierarchy in the test.
+- Nav: Fixed an issue with losing focus on docked windows when pressing Alt while keyboard navigation
+ is disabled. (#4547, #4439) [@PathogenDavid]
+- Docking: Fixed IsItemHovered() and functions depending on it (e.g. BeginPopupContextItem()) when
+ called after Begin() on a docked window (broken 2021/03/04). (#3851)
+- Docking: Improved resizing system so that non-central zone are better at keeping their fixed size.
+ The algorithm is still not handling the allocation of size ideally for nested sibling, but it got better.
+- Docking: Fixed settings load issue when mouse wheeling. (#4310)
+- Docking: Fixed manually created floating node with a central node from not hiding when windows are gone.
+- Docking + Drag and Drop: Fixed using BeginDragDropSource() or BeginDragDropTarget() inside a Begin()
+ that returned false because the window is docked. (#4515)
+- Viewports: Fixed a crash while a window owning its viewport disappear while being dragged.
+ It would manifest when e.g. reconfiguring dock nodes while dragging.
+- Viewports: Fixed unnecessary creation of temporary viewports when multiple docked windows
+ got reassigned to a new node (created mid-frame) which already has a HostWindow.
+- Viewports: Fixed window with viewport ini data immediately merged into a host viewport from
+ leaving a temporary viewport alive for a frame (would leak into backend).
+
-----------------------------------------------------------------------
VERSION 1.84.2 (Released 2021-08-23)
@@ -2462,6 +2760,25 @@
- Examples: Updated all .vcxproj to VS2015 (toolset v140) to facilitate usage with vcpkg.
- Examples: SDL2: Accommodate for vcpkg install having headers in SDL2/SDL.h vs SDL.h.
+Docking+Viewports Branch:
+
+- Docking: Clicking on the right-most close button of a docking node closes all windows. (#4186)
+- Docking: Fix IsWindowAppearing() and ImGuiCond_Appearing on docked windows. (#4177, #3982, #1497, #1061)
+- Docking: Fix crash using DockBuilderRemoveNode() in some situations. (#3111, #3179, #3203, #4295) [@hsimyu]
+- Docking: Fix crash when a dock node gets re-qualified as dockspace>floating>dockspace, which tends to happen
+ when incorrectly calling DockBuilderAddNode() without ImGuiDockNodeFlags_Dockspace and using it as a Dockspace
+ on the next frame after the floating window hosting the node has been automatically created. (#3203, #4295)
+- Docking: Reworked node flags saving/inheritance so that flags enforced by docked windows via the
+ DockNodeFlagsOverrideSet mechanism are are not left in empty dockspace nodes once the windows gets undocked.
+ (#4292, #3834, #3633, #3521, #3492, #3335, #2999, #2648)
+- Docking: (Internal/Experimental) Removed DockNodeFlagsOverrideClear flags from ImGuiWindowClass as
+ it is ambiguous how to apply them and we haven't got a use out of them yet.
+- Docking: Fixed ImGuiWindowFlags_UnsavedDocument clipping label in docked windows when there are
+ no close button. (#5745)
+- Viewports: Fix popup/tooltip created without a parent window from being given a ParentViewportId value
+ from the implicit/fallback window. (#4236, #2409)
+- Backends: Vulkan: Fix the use of the incorrect fence for secondary viewports. (#4208) [@FunMiles]
+
-----------------------------------------------------------------------
VERSION 1.83 (Released 2021-05-24)
@@ -2546,6 +2863,22 @@
- Docs: Improvements to description of using colored glyphs/emojis. (#4169, #3369)
- Docs: Improvements to minor mistakes in documentation comments (#3923) [@ANF-Studios]
+Docking+Viewports Branch:
+
+- [Breaking] Removed io.ConfigDockingWithShift config option. Behavior always equivalent to having the
+ option set to false (dock/undock by default, hold shift to avoid docking). (#2109)
+- Docking: DockSpace() returns its node ID.
+- Docking: Dockspace() never draws a background. (#3924)
+- Docking: Undocking nodes/windows covering most of the monitor max their size down to 90% to ease manipulations.
+- Docking: Docking node tab bar honors ItemInnerSpacing.x before first tab. (#4130)
+- Docking: Tweak rendering and alignment of dock node menu marker. (#4130)
+- Docking: Fixed restoring of tab order within a dockspace or a split node.
+- Docking: Fixed reappearing docked windows with no close button showing a tab with extraneous space for one frame.
+- Docking: Fixed multiple simultaneously reappearing window from appearing undocked for one frame.
+- Viewports: Hotfix for crash in monitor array access, caused by 4b9bc4902. (#3967)
+- Backends, Viewports: GLFW: Add a workaround for stuck keys after closing a GLFW window (#3837).
+- Backends, Viewports: Vulkan: Rebuild swapchain on VK_SUBOPTIMAL_KHR. (#3881)
+
-----------------------------------------------------------------------
VERSION 1.82 (Released 2021-02-15)
@@ -2641,6 +2974,13 @@
scheduled builds builds are not required. [@rokups]
- Log/Capture: Added LogTextV, a va_list variant of LogText. [@PathogenDavid]
+Docking+Viewports Branch:
+
+- Viewports: Fix setting of ImGuiViewportFlags_NoRendererClear. (#3213)
+- Viewports: Added GetViewportPlatformMonitor() with a safety net to keep code portable.
+- Viewports, Backends: SDL: Fix missing ImGuiBackendFlags_HasSetMousePos flag in docking branch.
+- Viewports, Backends: GLFW: Fix application of WantSetMousePos. (#1542, #787)
+
-----------------------------------------------------------------------
VERSION 1.81 (Released 2021-02-10)
@@ -2722,6 +3062,17 @@
- Examples: WebGPU: Added Emscripten+WebGPU example. (#3632) [@bfierz]
- Backends: GLFW: Added ImGui_ImplGlfw_InitForOther() initialization call to use with non OpenGL API. (#3632)
+Docking+Viewports Branch:
+
+- Docking: Fix losing docking information on closed windows for which the hosting node was split. (#3716) [@GamingMinds-DanielC]
+- Docking: Fix gap in hit test hole when using ImGuiDockNodeFlags_PassthruCentralNode touching the edge of a viewport. (#3733)
+- Viewports: (Breaking) removed ImGuiPlatformIO::MainViewport which is now pretty much unused and duplicate
+ (and misleading as we will evolve the concept).
+- Viewports: (Breaking) turned ImGuiViewport::GetWorkPos(), ImGuiViewport::GetWorkSize() into regular fields
+ (WorkPos, WorkSize) before exposing in master branch.
+- Viewports: Fix issue inferring viewport z-order when new popups gets created. (#3734) + Metrics updates.
+- Viewports, Backends: Vulkan: handle VK_ERROR_OUT_OF_DATE_KHR when resizing secondary viewport (#3766, #3758)
+
-----------------------------------------------------------------------
VERSION 1.80 (Released 2021-01-21)
@@ -2841,6 +3192,14 @@
- Docs: Split examples/README.txt into docs/BACKENDS.md and docs/EXAMPLES.md, and improved them.
- Docs: Consistently renamed all occurrences of "binding" and "back-end" to "backend" in comments and docs.
+Docking+Viewports Branch:
+
+- Docking: Docked windows honor change of tab and text colors. (#2771)
+- Docking: Support for appending into existing tab-bar made to work with Docking + internal helper DockNodeBeginAmendTabBar().
+- Docking: Added experimental TabItemFlagsOverrideSet to ImGuiWindowClass.
+- Viewports: Fixed incorrect whitening of popups above a modal if both use their own viewport.
+- Viewports: Backends: Vulkan: Fixed build, removed extraneous pipeline creation. (#3459, #3579)
+
-----------------------------------------------------------------------
VERSION 1.79 (Released 2020-10-08)
@@ -2935,6 +3294,21 @@
- Examples: DX12: Added '#define ImTextureID ImU64' in project and build files to also allow building
on 32-bit systems. Added project to default Visual Studio solution file. (#301)
+Docking+Viewports Branch:
+
+- Docking: DockSpace() emits ItemSize() properly (useful when not filling all space).
+- Docking: Fixed docking while hovering a child window. (#3420) broken by 85a661d. Improve metrics debugging.
+- Docking: Fix honoring payload filter with overlapping nodes (we incorrectly over-relied on g.HoveredDockNode
+ when making change for #3398).
+- Docking: Fix handling of WindowMenuButtonPosition == ImGuiDir_None in Docking Nodes. (#3499)
+- Viewports: Fixed a rare edge-case if the window targeted by CTRL+Tab stops being rendered.
+- Viewports, Backends: DX12: Make secondary viewport format match main viewport one (#3462) {@BeastLe9enD]
+- Viewports: Backends: Vulkan: Removed unused shader code. Fix leaks. Avoid unnecessary pipeline creation for main
+ viewport. (#3459) + Add ImGui_ImplVulkanH_CreateWindowSwapChain in ImGui_ImplVulkanH_CreateOrResizeWindow().
+- Viewports: Backends: DirectX9: Recover from D3DERR_DEVICELOST on secondary viewports. (#3424)
+- Viewports, Backends: Win32: Fix toggling of ImGuiViewportFlags_TopMost (#3477) [@Kodokuna]
+- Viewports: Backends: GLFW: Workaround for cases where glfwGetMonitorWorkarea fails (#3457) [@dougbinks]
+
-----------------------------------------------------------------------
VERSION 1.78 (Released 2020-08-18)
@@ -3036,6 +3410,23 @@
- Examples: Vulkan: Fixed GLFW+Vulkan and SDL+Vulkan clear color not being set. (#3390) [@RoryO]
- CI: Emscripten has stopped their support for their fastcomp backend, switching to latest sdk [@Xipiryon]
+Docking+Viewports Branch:
+
+- Docking: Made DockBuilderAddNode() automatically call DockBuilderRemoveNode(). (#3399, #2109)
+- Docking: Storing HoveredDockNode in context which can be useful for easily detecting e.g. hovering an
+ empty node. (#3398)
+- Docking: Fixed docking overlay bits appearing at (0,0), because of 43bd80a. Most typically noticeable
+ when disabling multi-viewport.
+- Docking: Workaround recovery for node created without the _DockSpace flags later becoming a DockSpace. (#3340)
+- Docking: Rework size allocations to recover when there's no enough room for nodes + do not hold on
+ _WantLockSizeOnce forever. (#3328)
+- Docking: Rework size allocation to allow user code to override node sizes. Not all edge cases will be
+ properly handled but this is a step toward toolbar emitting size constraints.
+- Docking: Added experimental flags to perform more docking filtering and disable resize per axis.
+ Designed for toolbar patterns.
+- Viewports, Backends, GLFW: Use GLFW_MOUSE_PASSTHROUGH when available.
+- Viewports, Backends: DX12: Fixed issue on shutdown when viewports are disabled. (#3347)
+
-----------------------------------------------------------------------
VERSION 1.77 (Released 2020-06-29)
@@ -3127,6 +3518,17 @@
- Examples: Apple: Fixed example_apple_metal and example_apple_opengl2 using imgui_impl_osx.mm
not forwarding right and center mouse clicks. (#3260) [@nburrus]
+Docking+Viewports Branch:
+
+- Viewports: Don't set ImGuiViewportFlags_NoRendererClear when ImGuiWindowFlags_NoBackground is set. (#3213)
+- Viewports: Report minimized viewports as zero DisplaySize to be consistent with main branch. (#1542)
+- Docking, Settings: Allow reload of settings data at runtime. (#2573)
+- Backends, GLFW: Fix windows resizing incorrectly on Linux due to GLFW firing window positioning
+ callbacks on next frame after window is resized manually. (#2117)
+- Backends: DX12: Fix OBJECT_DELETED_WHILE_STILL_IN_USE on viewport resizing. (#3210)
+- Backends: DX12: Fix for crash caused by early resource release. (#3121)
+- Backends, Win32: Request monitor update when DPI awareness is enabled to make sure they have the correct DPI settings.
+
-----------------------------------------------------------------------
VERSION 1.76 (Released 2020-04-12)
@@ -3199,6 +3601,20 @@
- Examples: SDL+DX11: Fixed resizing main window. (#3057) [@joeslay]
- Examples: Added SDL+Metal example application. (#3017) [@coding-jackalope]
+Docking+Viewports Branch:
+
+- Docking: Fixed assert preventing dockspace from being created instead a hidden tab. (#3101)
+- Viewports: Fixed secondary viewports accidentally merging into a minimized host viewport. (#3118)
+- Viewports, Docking: Added per-viewport work area system for e.g. menu-bars. Fixed DockspaceOverViewport()
+ and demo code (overlay etc) accordingly. (#3035, #2889, #2474, #1542, #2109)
+- Viewports: Improve menu positioning in multi-monitor setups. [@rokups]
+- Viewports: Software mouse cursor is also scaled by current DpiScale. (amend #939)
+- Viewports: Avoid manually clipping resize grips and borders, which messes up with automation ability
+ to locate those items. Also simpler and more standard.
+- Viewports: Fix for UWP in the imgui_impl_win32.cpp IME handler. (#2895, #2892).
+- Viewports: Bunch of extra of comments to facilitate setting up multi-viewports.
+- Viewports, GLFW: Avoid using window positioning workaround for GLFW 3.3+ versions that have it fixed.
+
-----------------------------------------------------------------------
VERSION 1.75 (Released 2020-02-10)
@@ -3297,6 +3713,21 @@
- Examples: Metal: Wrapped main loop in @autoreleasepool block to ensure allocations get freed
even if underlying system event loop gets paused due to app nap. (#2910, #2917) [@bear24rw]
+Docking+Viewports Branch:
+
+- Docking + Nav: Fixed messed up Ctrl+Tab order with docked windows.
+- Docking + Nav: Fixed failing to restore NavId when refocusing a child within a docked window.
+- Docking + Nav: Fixed failing to restore NavId when refocusing due to missing nav window (when
+ it stops being submitted).
+- Docking: Fixed a bug where the tab bar of a hidden dockspace would keep requesting focus. (#2960)
+- Docking: Added experimental DockNodeFlagsOverrideSet/DockNodeFlagsOverrideClear flags in ImGuiWindowClass
+ (currently experimenting with toolbar idioms).
+- Viewports: Fix resizing viewport-owning windows when mouse pos is outside the InnerClipRect
+ (can happen with OS decoration enabled).
+- Viewports: Preserve last known size for minimized main viewport to be consistent with secondary viewports.
+- Backends: SDL: Honor NoTaskBarIcon flag under non Win32 OS. (#2117)
+- Backends: GLFW, SDL: Platform monitors declared properly even if multi-viewport is not enabled.
+
-----------------------------------------------------------------------
VERSION 1.74 (Released 2019-11-25)
@@ -3376,6 +3807,14 @@
- CI: Set up a bunch of continuous-integration tests using GitHub Actions. We now compile many of the example
applications on Windows, Linux, MacOS, iOS, Emscripten. Removed Travis integration. (#2865) [@rokups]
+Docking+Viewports Branch:
+
+- Docking: Can undock from the small triangle button. (#2109,. #2645)
+- Docking: Fixed node->HasCloseButton not honoring ImGuiDockNodeFlags_NoCloseButton in a floating node,
+ leading to empty space at the right of tab-bars with those flags. (#2109)
+- Docking: Made docked windows not use style.ChildRounding.
+- Multi-viewports: Added multi-viewport support in the DX12 back-end. (#2851) [@obfuscate]
+
-----------------------------------------------------------------------
VERSION 1.73 (Released 2019-09-24)
@@ -3438,6 +3877,28 @@
- Misc: Updated stb_rect_pack.h from 0.99 to 1.00 (fixes by @rygorous: off-by-1 bug in best-fit heuristic,
fix handling of rectangles too large to fit inside texture). (#2762) [@tido64]
+Docking+Viewports Branch:
+
+- Docking: Fix BeginDocked() path that creates node so that SetNextWindowDockID() doesn't immediately discard the node. (#2109)
+- Docking: Fix for node created at the same time as windows that are still resizing (typically with
+ io.ConfigDockingAlwaysTabBar) to not be zero/min sized. (#2109). The fix delays their visibility by one frame,
+ which is not ideal but not very problematic as the .ini data gets populated after that.
+- Docking: Fix a crash that could occur with a malformed ini file (DockNode Parent value pointing to a missing node).
+- Viewport: Fix modal/popup window being stuck in unowned hidden viewport associated to fallback window without stealing
+ it back. Fix modal reference viewport when opened outside of another window. (#1542)
+- Viewport: Modals don't need to set ImGuiViewportFlags_NoFocusOnClick, this also mitigate the issue described by #2445,
+ which becomes particularly bad with unfocused modal. (#1542)
+- Viewport: better case case where host window gets moved and resized simultaneous (toggling maximized state).
+ There's no perfect solution there, than using io.ConfigViewportsNoAutoMerge = false. (#1542)
+- Viewport, Docking: Fixed incorrect assignment of IsFallbackWindow which would tag dock node host windows created
+ in NewFrame() as such, messing with popup viewport inheritance.
+- Viewport: Fixed issue where resize grip would display as hovered while mouse is still off the OS bounds so a click
+ would miss it and focus the OS window behind expected one. (#1542)
+- Viewport: Fix to allow multiple shutdown / calls to DestroyPlatformWindows(). (#2769)
+- Viewport: Backends: GLFW: Fix setting window size on macOS (#2767, #2117) [@rokups]
+- Viewport: Backends: GLFW+Linux: Fix window having incorrect size after uncollapse. (#2756, #2117) [@rokups]
+- Viewport: Backends: DirectX9: Workaround for windows not refreshing when main viewport has no draw call. (#2560)
+
-----------------------------------------------------------------------
VERSION 1.72b (Released 2019-07-31)
@@ -3540,6 +4001,25 @@
(#2482, #2632) [@josiahmanson]
- Examples: Added SDL2+DirectX11 example application. (#2632, #2612, #2482) [@vincenthamm]
+Docking+Viewports Branch:
+
+- Docking: Making it possible to undock a node by clicking on the tab bar / title bar for the node. (#2645).
+- Docking: Explicitly inhibit constraint when docked for now. Fix clipping issue related to constraints. (#2690).
+- Docking: Fixed dragging/resizing from OS decoration not marking settings as dirty.
+- Docking: Renamed io.ConfigDockingTabBarOnSingleWindows to io.ConfigDockingAlwaysTabBar.
+ Added ImGuiWindowClass::DockingAlwaysTabBar to set on individual windows.
+- Docking: Perform simple check: assert if Docking or Viewport are enabled exactly on frame 1 (instead of frame 0
+ or later), which is a common user error leading to loss of .ini data on load.
+- Docking: Fix so that an appearing window making a dock node reappear won't have a zero-size on its first frame.
+- Docking: Fixed using ImGuiDockNodeFlags_AutoHideTabBar with io.ConfigDockingTabBarOnSingleWindows.
+- Docking: Added ImGuiDockNode to .natvis file.
+- Docking: Fixed support for large meshes in GetBackgroundDrawList(), GetForegroundDrawList(). (#2638)
+- Viewport: Fix monitor dpi info not being copied to main viewport when multi-viewports are not enabled. (#2621, #1676)
+- Viewport: Refactored ImGuiWindowClass's ViewportFlagsOverrideMask + ViewportFlagsOverrideValue into
+ ViewportFlagsOverrideSet + ViewportFlagsOverrideClear which appears easier to grasp. (#1542)
+- Viewport: Added ImGuiViewportFlags_NoAutoMerge to prevent merging into host viewport in a per-window basis
+ via the ImGuiWindowClass override mechanism. (#1542)
+
-----------------------------------------------------------------------
VERSION 1.71 (Released 2019-06-12)
@@ -3879,6 +4359,7 @@
- Renamed ImFontAtlas::GlyphRangesBuilder to ImFontGlyphRangesBuilder. Kept redirection typedef (will obsolete).
Other Changes:
+
- Added BETA api for Tab Bar/Tabs widgets: (#261, #351)
- Added BeginTabBar(), EndTabBar(), BeginTabItem(), EndTabItem(), SetTabItemClosed() API.
- Added ImGuiTabBarFlags flags for BeginTabBar().
diff --git a/docs/TODO.txt b/docs/TODO.txt
index 84a00bc..4f780c9 100644
--- a/docs/TODO.txt
+++ b/docs/TODO.txt
@@ -129,7 +129,35 @@
- separator: width, thickness, centering (#1643, #2657)
- splitter: formalize the splitter idiom into an official api (we want to handle n-way split) (#319)
- - docking: merge docking branch (#2109)
+ - docking: B: ordering currently held in tab bar should be implicitly held by windows themselves (also see #2304)
+ - docking: B- tab bar: the order/focus restoring code could be part of TabBar and not DockNode? (#8)
+ - docking: B~ rework code to be able to lazily create tab bar instance in a single place. The _Unsorted tab flag could be replacing a trailing-counter in DockNode?
+ - docking: B~ fully track windows/settings reference in dock nodes. perhaps find a representation that allows facilitate use of dock builder functions.
+ - docking: B~ Unreal style document system (requires low-level controls of dockspace serialization fork/copy/delete). this is mostly working but the DockBuilderXXX api are not exposed/finished.
+ - docking: B: when docking outer, perform size locking on neighbors nodes the same way we do it with splitters, so other nodes are not resized.
+ - docking: B~ central node resizing behavior incorrect.
+ - docking: B: changing title font/style per-window is not supported as dock nodes are created in NewFrame.
+ - docking: B- dock node inside its own viewports creates 1 temporary viewport per window on startup before ditching them (doesn't affect the user nor request platform windows to be created, but unnecessary)
+ - docking: B- resize sibling locking behavior may be less desirable if we merged same-axis sibling in a same node level?
+ - docking: B- single visible node part of a hidden split hierarchy (OnlyNodeWithWindows != NULL) should show a normal title bar (not a tab bar)
+ - docking: B~ SetNextWindowDock() calls (with conditional) -> defer everything to DockContextUpdate (repro: Documents->[X]Windows->Dock 1 elsewhere->Click Redock All
+ - docking: B~ tidy up tab list popup buttons features (available with manual tab-bar, see ImGuiTabBarFlags_NoTabListPopupButton code, not used by docking nodes)
+ - docking: B- SetNextWindowDockId(0) with a second Begin() in the frame will asserts
+ - docking: B: resize grip drawn in host window typically appears under scrollbar.
+ - docking: B: resize grip auto-resize on multiple node hierarchy doesn't make much sense or should be improved?
+ - docking: B- SetNextWindowFocus() doesn't seem to apply if the window is hidden this frame, need repro (#4)
+ - docking: B- resizing a dock tree small currently has glitches (overlapping collapse and close button, etc.)
+ - docking: B- dpi: look at interaction with the hi-dpi and multi-dpi stuff.
+ - docking: B- tab bar: appearing on first frame with a dumb layout would do less harm that not appearing? (when behind dynamic branch) or store titles + render in EndTabBar()
+ - docking: B- tab bar: make selected tab always shows its full title?
+ - docking: B- hide close button on single tab bar?
+ - docking: B- nav: design interactions so nav controls can dock/undock
+ - docking: B- dockspace: flag to lock the dock tree and/or sizes (ImGuiDockNodeFlags_Locked?)
+ - docking: B- reintroduce collapsing a floating dock node. also collapsing a docked dock node!
+ - docking: B- allow dragging a non-floating dock node by clicking on the title-bar-looking section (not just the collapse/menu button)
+ - docking: B- option to remember undocked window size? (instead of keeping their docked size) (relate to #2104)
+ - docking: C- nav: CTRL+TAB highlighting tabs shows the mismatch between focus-stack and tab-order (not visible in VS because it doesn't highlight the tabs)
+ - docking: C- after a dock/undock, the Scrollbar Status update in Begin() should use an updated e.g. size_y_for_scrollbars to avoid a 1 frame scrollbar flicker.
- tabs: "there is currently a problem because TabItem() will try to submit their own tooltip after 0.50 second, and this will have the effect of making your tooltip flicker once." -> tooltip priority work (WIP branch)
- tabs: make EndTabBar fail if users doesn't respect BeginTabBar return value, for consistency/future-proofing.
@@ -302,6 +330,20 @@
- nav/windowing: Resizing window will currently fail with certain types of resizing constraints/callback applied
- focus: preserve ActiveId/focus stack state, e.g. when opening a menu and close it, previously selected InputText() focus gets restored (#622)
+ - viewport: make it possible to have no main/hosting viewport
+ - viewport: We set ImGuiViewportFlags_NoFocusOnAppearing in a way that is required for GLFW/SDL binding, but could be handled better without
+ on a custom e.g. Win32 bindings. It prevents newly dragged-out viewports from taking the focus, which makes ALT+F4 more ambiguous.
+ - viewport: not focusing newly undocked viewport means clicking back on previous one doesn't bring OS window to front.
+ - viewport: with platform decoration enabled, platform may force constraint (e.g. minimum size)
+ - viewport: use getfocus/setfocus api to synchronize imgui<>platform focus better (e.g imgui-side ctrl-tab can focus os window, OS initial setup and alt-tab can focus imgui window etc.)
+ - viewport: store per-viewport/monitor DPI in .ini file so an application reload or main window changing DPI on reload can be properly patched for.
+ - viewport: implicit/fallback Debug window can hog a zombie viewport (harmless, noisy?) > could at least clear out the reference on a per session basis?
+ - viewport: need to clarify how to use GetMousePos() from a user point of view.
+ - platform: glfw: no support for ImGuiBackendFlags_HasMouseHoveredViewport.
+ - platform: sdl: no support for ImGuiBackendFlags_HasMouseHoveredViewport. maybe we could use SDL_GetMouseFocus() / SDL_WINDOW_MOUSE_FOCUS if imgui could fallback on its heuristic when NoInputs is set
+ - platform: sdl: no refresh of monitor/display (SDL doesn't seem to have an event for it).
+ - platform: sdl: multi-viewport + minimized window seems to break mouse wheel events (at least under Win32).
+
- inputs: support track pad style scrolling & slider edit.
- inputs/io: backspace and arrows in the context of a text input could use system repeat rate.
- inputs/io: clarify/standardize/expose repeat rate and repeat delays (#1808)
diff --git a/examples/example_allegro5/main.cpp b/examples/example_allegro5/main.cpp
index 3ca061c..298c845 100644
--- a/examples/example_allegro5/main.cpp
+++ b/examples/example_allegro5/main.cpp
@@ -40,6 +40,7 @@
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
// Setup Dear ImGui style
ImGui::StyleColorsDark();
diff --git a/examples/example_apple_metal/example_apple_metal.xcodeproj/project.pbxproj b/examples/example_apple_metal/example_apple_metal.xcodeproj/project.pbxproj
index 4bb4fc2..3ebf9cc 100644
--- a/examples/example_apple_metal/example_apple_metal.xcodeproj/project.pbxproj
+++ b/examples/example_apple_metal/example_apple_metal.xcodeproj/project.pbxproj
@@ -7,7 +7,10 @@
objects = {
/* Begin PBXBuildFile section */
+ 050450AB2768052600AB6805 /* imgui_tables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5079822D257677DB0038A28D /* imgui_tables.cpp */; };
+ 050450AD276863B000AB6805 /* QuartzCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 050450AC276863B000AB6805 /* QuartzCore.framework */; };
05318E0F274C397200A8DE2E /* GameController.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 05318E0E274C397200A8DE2E /* GameController.framework */; };
+ 05A275442773BEA20084EF39 /* QuartzCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 05A275432773BEA20084EF39 /* QuartzCore.framework */; };
07A82ED82139413D0078D120 /* imgui_widgets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07A82ED72139413C0078D120 /* imgui_widgets.cpp */; };
07A82ED92139418F0078D120 /* imgui_widgets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07A82ED72139413C0078D120 /* imgui_widgets.cpp */; };
5079822E257677DB0038A28D /* imgui_tables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5079822D257677DB0038A28D /* imgui_tables.cpp */; };
@@ -33,7 +36,11 @@
/* End PBXBuildFile section */
/* Begin PBXFileReference section */
+ 050450AC276863B000AB6805 /* QuartzCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuartzCore.framework; path = System/Library/Frameworks/QuartzCore.framework; sourceTree = SDKROOT; };
05318E0E274C397200A8DE2E /* GameController.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = GameController.framework; path = System/Library/Frameworks/GameController.framework; sourceTree = SDKROOT; };
+ 05A2754027728F5B0084EF39 /* imgui_impl_metal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = imgui_impl_metal.h; path = ../../backends/imgui_impl_metal.h; sourceTree = "<group>"; };
+ 05A2754127728F5B0084EF39 /* imgui_impl_osx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = imgui_impl_osx.h; path = ../../backends/imgui_impl_osx.h; sourceTree = "<group>"; };
+ 05A275432773BEA20084EF39 /* QuartzCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuartzCore.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS15.2.sdk/System/Library/Frameworks/QuartzCore.framework; sourceTree = DEVELOPER_DIR; };
07A82ED62139413C0078D120 /* imgui_internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = imgui_internal.h; path = ../../imgui_internal.h; sourceTree = "<group>"; };
07A82ED72139413C0078D120 /* imgui_widgets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = imgui_widgets.cpp; path = ../../imgui_widgets.cpp; sourceTree = "<group>"; };
5079822D257677DB0038A28D /* imgui_tables.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = imgui_tables.cpp; path = ../../imgui_tables.cpp; sourceTree = "<group>"; };
@@ -66,6 +73,7 @@
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
+ 05A275442773BEA20084EF39 /* QuartzCore.framework in Frameworks */,
8309BD8F253CCAAA0045E2A1 /* UIKit.framework in Frameworks */,
83BBE9E720EB46BD00295997 /* MetalKit.framework in Frameworks */,
83BBE9E520EB46B900295997 /* Metal.framework in Frameworks */,
@@ -76,6 +84,7 @@
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
+ 050450AD276863B000AB6805 /* QuartzCore.framework in Frameworks */,
8309BDC6253CCCFE0045E2A1 /* AppKit.framework in Frameworks */,
83BBE9EC20EB471700295997 /* MetalKit.framework in Frameworks */,
05318E0F274C397200A8DE2E /* GameController.framework in Frameworks */,
@@ -136,6 +145,8 @@
83BBE9E320EB46B800295997 /* Frameworks */ = {
isa = PBXGroup;
children = (
+ 050450AC276863B000AB6805 /* QuartzCore.framework */,
+ 05A275432773BEA20084EF39 /* QuartzCore.framework */,
05318E0E274C397200A8DE2E /* GameController.framework */,
8309BDC5253CCCFE0045E2A1 /* AppKit.framework */,
8309BD8E253CCAAA0045E2A1 /* UIKit.framework */,
@@ -153,7 +164,9 @@
isa = PBXGroup;
children = (
5079822D257677DB0038A28D /* imgui_tables.cpp */,
+ 05A2754027728F5B0084EF39 /* imgui_impl_metal.h */,
8309BDB5253CCC9D0045E2A1 /* imgui_impl_metal.mm */,
+ 05A2754127728F5B0084EF39 /* imgui_impl_osx.h */,
8309BDB6253CCC9D0045E2A1 /* imgui_impl_osx.mm */,
83BBEA0420EB54E700295997 /* imconfig.h */,
83BBEA0320EB54E700295997 /* imgui.cpp */,
@@ -268,9 +281,9 @@
8309BDBB253CCCAD0045E2A1 /* imgui_impl_metal.mm in Sources */,
83BBEA0920EB54E700295997 /* imgui.cpp in Sources */,
83BBEA0720EB54E700295997 /* imgui_demo.cpp in Sources */,
- 83BBEA0520EB54E700295997 /* imgui_draw.cpp in Sources */,
+ 83BBEA0520EB54E700295997 /* imgui_draw.cpp in Sources */,
5079822E257677DB0038A28D /* imgui_tables.cpp in Sources */,
- 07A82ED82139413D0078D120 /* imgui_widgets.cpp in Sources */,
+ 07A82ED82139413D0078D120 /* imgui_widgets.cpp in Sources */,
8309BDA5253CCC070045E2A1 /* main.mm in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
@@ -281,10 +294,10 @@
files = (
8309BDBE253CCCB60045E2A1 /* imgui_impl_metal.mm in Sources */,
8309BDBF253CCCB60045E2A1 /* imgui_impl_osx.mm in Sources */,
- 83BBEA0A20EB54E700295997 /* imgui.cpp in Sources */,
- 83BBEA0820EB54E700295997 /* imgui_demo.cpp in Sources */,
- 83BBEA0620EB54E700295997 /* imgui_draw.cpp in Sources */,
- 5079822E257677DB0038A28D /* imgui_tables.cpp in Sources */,
+ 83BBEA0A20EB54E700295997 /* imgui.cpp in Sources */,
+ 83BBEA0820EB54E700295997 /* imgui_demo.cpp in Sources */,
+ 83BBEA0620EB54E700295997 /* imgui_draw.cpp in Sources */,
+ 050450AB2768052600AB6805 /* imgui_tables.cpp in Sources */,
07A82ED92139418F0078D120 /* imgui_widgets.cpp in Sources */,
8309BDA8253CCC080045E2A1 /* main.mm in Sources */,
);
diff --git a/examples/example_apple_metal/main.mm b/examples/example_apple_metal/main.mm
index 109ef61..d184dd6 100644
--- a/examples/example_apple_metal/main.mm
+++ b/examples/example_apple_metal/main.mm
@@ -60,11 +60,21 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Renderer backend
ImGui_ImplMetal_Init(_device);
@@ -195,6 +205,13 @@
// Present
[commandBuffer presentDrawable:view.currentDrawable];
[commandBuffer commit];
+
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
}
-(void)mtkView:(MTKView*)view drawableSizeWillChange:(CGSize)size
diff --git a/examples/example_apple_opengl2/main.mm b/examples/example_apple_opengl2/main.mm
index 815c0f7..11829a8 100644
--- a/examples/example_apple_opengl2/main.mm
+++ b/examples/example_apple_opengl2/main.mm
@@ -47,11 +47,21 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplOSX_Init(self);
ImGui_ImplOpenGL2_Init();
@@ -136,6 +146,13 @@
ImGui_ImplOpenGL2_RenderDrawData(draw_data);
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
// Present
[[self openGLContext] flushBuffer];
diff --git a/examples/example_glfw_metal/main.mm b/examples/example_glfw_metal/main.mm
index e9bc63a..2f346ff 100644
--- a/examples/example_glfw_metal/main.mm
+++ b/examples/example_glfw_metal/main.mm
@@ -33,11 +33,21 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
// Setup style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Load Fonts
// - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
// - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
@@ -69,7 +79,7 @@
id <MTLCommandQueue> commandQueue = [device newCommandQueue];
// Setup Platform/Renderer backends
- ImGui_ImplGlfw_InitForOpenGL(window, true);
+ ImGui_ImplGlfw_InitForOther(window, true);
ImGui_ImplMetal_Init(device);
NSWindow *nswin = glfwGetCocoaWindow(window);
@@ -157,6 +167,13 @@
ImGui::Render();
ImGui_ImplMetal_RenderDrawData(ImGui::GetDrawData(), commandBuffer, renderEncoder);
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
[renderEncoder popDebugGroup];
[renderEncoder endEncoding];
diff --git a/examples/example_glfw_opengl2/main.cpp b/examples/example_glfw_opengl2/main.cpp
index 1fcec2b..df14dca 100644
--- a/examples/example_glfw_opengl2/main.cpp
+++ b/examples/example_glfw_opengl2/main.cpp
@@ -52,11 +52,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL2_Init();
@@ -155,6 +167,17 @@
ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
//glUseProgram(last_program);
+ // Update and Render additional Platform Windows
+ // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
+ // For this specific demo app we could also call glfwMakeContextCurrent(window) directly)
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ GLFWwindow* backup_current_context = glfwGetCurrentContext();
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ glfwMakeContextCurrent(backup_current_context);
+ }
+
glfwMakeContextCurrent(window);
glfwSwapBuffers(window);
}
diff --git a/examples/example_glfw_opengl3/main.cpp b/examples/example_glfw_opengl3/main.cpp
index 3afe251..ab12364 100644
--- a/examples/example_glfw_opengl3/main.cpp
+++ b/examples/example_glfw_opengl3/main.cpp
@@ -77,11 +77,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplGlfw_InitForOpenGL(window, true);
#ifdef __EMSCRIPTEN__
@@ -184,6 +196,17 @@
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+ // Update and Render additional Platform Windows
+ // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
+ // For this specific demo app we could also call glfwMakeContextCurrent(window) directly)
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ GLFWwindow* backup_current_context = glfwGetCurrentContext();
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ glfwMakeContextCurrent(backup_current_context);
+ }
+
glfwSwapBuffers(window);
}
#ifdef __EMSCRIPTEN__
diff --git a/examples/example_glfw_vulkan/main.cpp b/examples/example_glfw_vulkan/main.cpp
index 901b46c..2e63bbc 100644
--- a/examples/example_glfw_vulkan/main.cpp
+++ b/examples/example_glfw_vulkan/main.cpp
@@ -429,11 +429,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplGlfw_InitForVulkan(window, true);
ImGui_ImplVulkan_InitInfo init_info = {};
@@ -544,17 +556,25 @@
// Rendering
ImGui::Render();
- ImDrawData* draw_data = ImGui::GetDrawData();
- const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
- if (!is_minimized)
+ ImDrawData* main_draw_data = ImGui::GetDrawData();
+ const bool main_is_minimized = (main_draw_data->DisplaySize.x <= 0.0f || main_draw_data->DisplaySize.y <= 0.0f);
+ wd->ClearValue.color.float32[0] = clear_color.x * clear_color.w;
+ wd->ClearValue.color.float32[1] = clear_color.y * clear_color.w;
+ wd->ClearValue.color.float32[2] = clear_color.z * clear_color.w;
+ wd->ClearValue.color.float32[3] = clear_color.w;
+ if (!main_is_minimized)
+ FrameRender(wd, main_draw_data);
+
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
{
- wd->ClearValue.color.float32[0] = clear_color.x * clear_color.w;
- wd->ClearValue.color.float32[1] = clear_color.y * clear_color.w;
- wd->ClearValue.color.float32[2] = clear_color.z * clear_color.w;
- wd->ClearValue.color.float32[3] = clear_color.w;
- FrameRender(wd, draw_data);
- FramePresent(wd);
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
}
+
+ // Present Main Platform Window
+ if (!main_is_minimized)
+ FramePresent(wd);
}
// Cleanup
diff --git a/examples/example_glfw_wgpu/main.cpp b/examples/example_glfw_wgpu/main.cpp
index f510987..723b69d 100644
--- a/examples/example_glfw_wgpu/main.cpp
+++ b/examples/example_glfw_wgpu/main.cpp
@@ -93,6 +93,7 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
// Setup Dear ImGui style
ImGui::StyleColorsDark();
diff --git a/examples/example_glut_opengl2/main.cpp b/examples/example_glut_opengl2/main.cpp
index 58539ca..4edae6f 100644
--- a/examples/example_glut_opengl2/main.cpp
+++ b/examples/example_glut_opengl2/main.cpp
@@ -61,6 +61,7 @@
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
// Setup Dear ImGui style
ImGui::StyleColorsDark();
@@ -78,7 +79,6 @@
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
ImGui_ImplGLUT_InstallFuncs();
-
// Load Fonts
// - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
// - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
diff --git a/examples/example_sdl2_directx11/main.cpp b/examples/example_sdl2_directx11/main.cpp
index 47c852d..7b7de21 100644
--- a/examples/example_sdl2_directx11/main.cpp
+++ b/examples/example_sdl2_directx11/main.cpp
@@ -71,11 +71,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplSDL2_InitForD3D(window);
ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
@@ -181,6 +193,13 @@
g_pd3dDeviceContext->ClearRenderTargetView(g_mainRenderTargetView, clear_color_with_alpha);
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
g_pSwapChain->Present(1, 0); // Present with vsync
//g_pSwapChain->Present(0, 0); // Present without vsync
}
diff --git a/examples/example_sdl2_metal/main.mm b/examples/example_sdl2_metal/main.mm
index d548127..5cd7043 100644
--- a/examples/example_sdl2_metal/main.mm
+++ b/examples/example_sdl2_metal/main.mm
@@ -24,11 +24,21 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
// Setup style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Load Fonts
// - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
// - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
@@ -168,6 +178,13 @@
ImGui::Render();
ImGui_ImplMetal_RenderDrawData(ImGui::GetDrawData(), commandBuffer, renderEncoder);
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
[renderEncoder popDebugGroup];
[renderEncoder endEncoding];
diff --git a/examples/example_sdl2_opengl2/main.cpp b/examples/example_sdl2_opengl2/main.cpp
index a70edd2..4c537c3 100644
--- a/examples/example_sdl2_opengl2/main.cpp
+++ b/examples/example_sdl2_opengl2/main.cpp
@@ -57,11 +57,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
ImGui_ImplOpenGL2_Init();
@@ -160,6 +172,19 @@
glClear(GL_COLOR_BUFFER_BIT);
//glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound
ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
+
+ // Update and Render additional Platform Windows
+ // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
+ // For this specific demo app we could also call SDL_GL_MakeCurrent(window, gl_context) directly)
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ SDL_Window* backup_current_window = SDL_GL_GetCurrentWindow();
+ SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ SDL_GL_MakeCurrent(backup_current_window, backup_current_context);
+ }
+
SDL_GL_SwapWindow(window);
}
diff --git a/examples/example_sdl2_opengl3/main.cpp b/examples/example_sdl2_opengl3/main.cpp
index 2a4d7b9..12bd123 100644
--- a/examples/example_sdl2_opengl3/main.cpp
+++ b/examples/example_sdl2_opengl3/main.cpp
@@ -84,11 +84,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
ImGui_ImplOpenGL3_Init(glsl_version);
@@ -194,6 +206,19 @@
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+ // Update and Render additional Platform Windows
+ // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
+ // For this specific demo app we could also call SDL_GL_MakeCurrent(window, gl_context) directly)
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ SDL_Window* backup_current_window = SDL_GL_GetCurrentWindow();
+ SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ SDL_GL_MakeCurrent(backup_current_window, backup_current_context);
+ }
+
SDL_GL_SwapWindow(window);
}
#ifdef __EMSCRIPTEN__
diff --git a/examples/example_sdl2_sdlrenderer2/main.cpp b/examples/example_sdl2_sdlrenderer2/main.cpp
index 31fa3f9..e922873 100644
--- a/examples/example_sdl2_sdlrenderer2/main.cpp
+++ b/examples/example_sdl2_sdlrenderer2/main.cpp
@@ -59,6 +59,7 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
// Setup Dear ImGui style
ImGui::StyleColorsDark();
diff --git a/examples/example_sdl2_vulkan/main.cpp b/examples/example_sdl2_vulkan/main.cpp
index cb116b7..bc93057 100644
--- a/examples/example_sdl2_vulkan/main.cpp
+++ b/examples/example_sdl2_vulkan/main.cpp
@@ -429,11 +429,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigFlags |= ImGuiConfigFlags_ViewportsNoTaskBarIcons;
+ //io.ConfigFlags |= ImGuiConfigFlags_ViewportsNoMerge;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplSDL2_InitForVulkan(window);
ImGui_ImplVulkan_InitInfo init_info = {};
@@ -553,17 +565,25 @@
// Rendering
ImGui::Render();
- ImDrawData* draw_data = ImGui::GetDrawData();
- const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
- if (!is_minimized)
+ ImDrawData* main_draw_data = ImGui::GetDrawData();
+ const bool main_is_minimized = (main_draw_data->DisplaySize.x <= 0.0f || main_draw_data->DisplaySize.y <= 0.0f);
+ wd->ClearValue.color.float32[0] = clear_color.x * clear_color.w;
+ wd->ClearValue.color.float32[1] = clear_color.y * clear_color.w;
+ wd->ClearValue.color.float32[2] = clear_color.z * clear_color.w;
+ wd->ClearValue.color.float32[3] = clear_color.w;
+ if (!main_is_minimized)
+ FrameRender(wd, main_draw_data);
+
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
{
- wd->ClearValue.color.float32[0] = clear_color.x * clear_color.w;
- wd->ClearValue.color.float32[1] = clear_color.y * clear_color.w;
- wd->ClearValue.color.float32[2] = clear_color.z * clear_color.w;
- wd->ClearValue.color.float32[3] = clear_color.w;
- FrameRender(wd, draw_data);
- FramePresent(wd);
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
}
+
+ // Present Main Platform Window
+ if (!main_is_minimized)
+ FramePresent(wd);
}
// Cleanup
diff --git a/examples/example_sdl3_opengl3/main.cpp b/examples/example_sdl3_opengl3/main.cpp
index 0ba09dc..ee4976a 100644
--- a/examples/example_sdl3_opengl3/main.cpp
+++ b/examples/example_sdl3_opengl3/main.cpp
@@ -80,11 +80,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplSDL3_InitForOpenGL(window, gl_context);
ImGui_ImplOpenGL3_Init(glsl_version);
@@ -190,6 +202,19 @@
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+ // Update and Render additional Platform Windows
+ // (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
+ // For this specific demo app we could also call SDL_GL_MakeCurrent(window, gl_context) directly)
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ SDL_Window* backup_current_window = SDL_GL_GetCurrentWindow();
+ SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ SDL_GL_MakeCurrent(backup_current_window, backup_current_context);
+ }
+
SDL_GL_SwapWindow(window);
}
#ifdef __EMSCRIPTEN__
diff --git a/examples/example_sdl3_sdlrenderer3/main.cpp b/examples/example_sdl3_sdlrenderer3/main.cpp
index ef98d75..9ebf850 100644
--- a/examples/example_sdl3_sdlrenderer3/main.cpp
+++ b/examples/example_sdl3_sdlrenderer3/main.cpp
@@ -55,6 +55,7 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
// Setup Dear ImGui style
ImGui::StyleColorsDark();
diff --git a/examples/example_win32_directx10/main.cpp b/examples/example_win32_directx10/main.cpp
index 21198da..a9e5e31 100644
--- a/examples/example_win32_directx10/main.cpp
+++ b/examples/example_win32_directx10/main.cpp
@@ -54,11 +54,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX10_Init(g_pd3dDevice);
@@ -167,6 +179,13 @@
g_pd3dDevice->ClearRenderTargetView(g_mainRenderTargetView, clear_color_with_alpha);
ImGui_ImplDX10_RenderDrawData(ImGui::GetDrawData());
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
// Present
HRESULT hr = g_pSwapChain->Present(1, 0); // Present with vsync
//HRESULT hr = g_pSwapChain->Present(0, 0); // Present without vsync
@@ -186,7 +205,6 @@
}
// Helper functions
-
bool CreateDeviceD3D(HWND hWnd)
{
// Setup swap chain
diff --git a/examples/example_win32_directx11/main.cpp b/examples/example_win32_directx11/main.cpp
index 5285df1..d25213b 100644
--- a/examples/example_win32_directx11/main.cpp
+++ b/examples/example_win32_directx11/main.cpp
@@ -54,11 +54,28 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
+ //io.ConfigViewportsNoDefaultParent = true;
+ //io.ConfigDockingAlwaysTabBar = true;
+ //io.ConfigDockingTransparentPayload = true;
+ //io.ConfigFlags |= ImGuiConfigFlags_DpiEnableScaleFonts; // FIXME-DPI: Experimental. THIS CURRENTLY DOESN'T WORK AS EXPECTED. DON'T USE IN USER APP!
+ //io.ConfigFlags |= ImGuiConfigFlags_DpiEnableScaleViewports; // FIXME-DPI: Experimental.
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
@@ -167,6 +184,13 @@
g_pd3dDeviceContext->ClearRenderTargetView(g_mainRenderTargetView, clear_color_with_alpha);
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
// Present
HRESULT hr = g_pSwapChain->Present(1, 0); // Present with vsync
//HRESULT hr = g_pSwapChain->Present(0, 0); // Present without vsync
@@ -186,7 +210,6 @@
}
// Helper functions
-
bool CreateDeviceD3D(HWND hWnd)
{
// Setup swap chain
@@ -241,6 +264,10 @@
if (g_mainRenderTargetView) { g_mainRenderTargetView->Release(); g_mainRenderTargetView = nullptr; }
}
+#ifndef WM_DPICHANGED
+#define WM_DPICHANGED 0x02E0 // From Windows SDK 8.1+ headers
+#endif
+
// Forward declare message handler from imgui_impl_win32.cpp
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
@@ -269,6 +296,15 @@
case WM_DESTROY:
::PostQuitMessage(0);
return 0;
+ case WM_DPICHANGED:
+ if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_DpiEnableScaleViewports)
+ {
+ //const int dpi = HIWORD(wParam);
+ //printf("WM_DPICHANGED to %d (%.0f%%)\n", dpi, (float)dpi / 96.0f * 100.0f);
+ const RECT* suggested_rect = (RECT*)lParam;
+ ::SetWindowPos(hWnd, nullptr, suggested_rect->left, suggested_rect->top, suggested_rect->right - suggested_rect->left, suggested_rect->bottom - suggested_rect->top, SWP_NOZORDER | SWP_NOACTIVATE);
+ }
+ break;
}
return ::DefWindowProcW(hWnd, msg, wParam, lParam);
}
diff --git a/examples/example_win32_directx12/main.cpp b/examples/example_win32_directx12/main.cpp
index 57a481c..9479b43 100644
--- a/examples/example_win32_directx12/main.cpp
+++ b/examples/example_win32_directx12/main.cpp
@@ -90,11 +90,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX12_Init(g_pd3dDevice, NUM_FRAMES_IN_FLIGHT,
@@ -220,6 +232,13 @@
g_pd3dCommandQueue->ExecuteCommandLists(1, (ID3D12CommandList* const*)&g_pd3dCommandList);
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault(nullptr, (void*)g_pd3dCommandList);
+ }
+
// Present
HRESULT hr = g_pSwapChain->Present(1, 0); // Present with vsync
//HRESULT hr = g_pSwapChain->Present(0, 0); // Present without vsync
@@ -246,7 +265,6 @@
}
// Helper functions
-
bool CreateDeviceD3D(HWND hWnd)
{
// Setup swap chain
diff --git a/examples/example_win32_directx9/main.cpp b/examples/example_win32_directx9/main.cpp
index 422248b..8063636 100644
--- a/examples/example_win32_directx9/main.cpp
+++ b/examples/example_win32_directx9/main.cpp
@@ -52,11 +52,23 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
+ //io.ConfigViewportsNoAutoMerge = true;
+ //io.ConfigViewportsNoTaskBarIcon = true;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX9_Init(g_pd3dDevice);
@@ -177,6 +189,14 @@
ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
g_pd3dDevice->EndScene();
}
+
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+ }
+
HRESULT result = g_pd3dDevice->Present(nullptr, nullptr, nullptr, nullptr);
if (result == D3DERR_DEVICELOST)
g_DeviceLost = true;
@@ -195,7 +215,6 @@
}
// Helper functions
-
bool CreateDeviceD3D(HWND hWnd)
{
if ((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == nullptr)
@@ -231,6 +250,10 @@
ImGui_ImplDX9_CreateDeviceObjects();
}
+#ifndef WM_DPICHANGED
+#define WM_DPICHANGED 0x02E0 // From Windows SDK 8.1+ headers
+#endif
+
// Forward declare message handler from imgui_impl_win32.cpp
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
@@ -259,6 +282,15 @@
case WM_DESTROY:
::PostQuitMessage(0);
return 0;
+ case WM_DPICHANGED:
+ if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_DpiEnableScaleViewports)
+ {
+ //const int dpi = HIWORD(wParam);
+ //printf("WM_DPICHANGED to %d (%.0f%%)\n", dpi, (float)dpi / 96.0f * 100.0f);
+ const RECT* suggested_rect = (RECT*)lParam;
+ ::SetWindowPos(hWnd, nullptr, suggested_rect->left, suggested_rect->top, suggested_rect->right - suggested_rect->left, suggested_rect->bottom - suggested_rect->top, SWP_NOZORDER | SWP_NOACTIVATE);
+ }
+ break;
}
return ::DefWindowProcW(hWnd, msg, wParam, lParam);
}
diff --git a/examples/example_win32_opengl3/main.cpp b/examples/example_win32_opengl3/main.cpp
index 8ecd27a..ffc6e3d 100644
--- a/examples/example_win32_opengl3/main.cpp
+++ b/examples/example_win32_opengl3/main.cpp
@@ -33,6 +33,42 @@
void ResetDeviceWGL();
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
+// Support function for multi-viewports
+// Unlike most other backend combination, we need specific hooks to combine Win32+OpenGL.
+// We could in theory decide to support Win32-specific code in OpenGL backend via e.g. an hypothetical ImGui_ImplOpenGL3_InitForRawWin32().
+static void Hook_Renderer_CreateWindow(ImGuiViewport* viewport)
+{
+ assert(viewport->RendererUserData == NULL);
+
+ WGL_WindowData* data = IM_NEW(WGL_WindowData);
+ CreateDeviceWGL((HWND)viewport->PlatformHandle, data);
+ viewport->RendererUserData = data;
+}
+
+static void Hook_Renderer_DestroyWindow(ImGuiViewport* viewport)
+{
+ if (viewport->RendererUserData != NULL)
+ {
+ WGL_WindowData* data = (WGL_WindowData*)viewport->RendererUserData;
+ CleanupDeviceWGL((HWND)viewport->PlatformHandle, data);
+ IM_DELETE(data);
+ viewport->RendererUserData = NULL;
+ }
+}
+
+static void Hook_Platform_RenderWindow(ImGuiViewport* viewport, void*)
+{
+ // Activate the platform window DC in the OpenGL rendering context
+ if (WGL_WindowData* data = (WGL_WindowData*)viewport->RendererUserData)
+ wglMakeCurrent(data->hDC, g_hRC);
+}
+
+static void Hook_Renderer_SwapBuffers(ImGuiViewport* viewport, void*)
+{
+ if (WGL_WindowData* data = (WGL_WindowData*)viewport->RendererUserData)
+ ::SwapBuffers(data->hDC);
+}
+
// Main code
int main(int, char**)
{
@@ -62,15 +98,39 @@
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+ io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
+ io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsClassic();
+ // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+ ImGuiStyle& style = ImGui::GetStyle();
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ style.WindowRounding = 0.0f;
+ style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+ }
+
// Setup Platform/Renderer backends
ImGui_ImplWin32_InitForOpenGL(hwnd);
ImGui_ImplOpenGL3_Init();
+ // Win32+GL needs specific hooks for viewport, as there are specific things needed to tie Win32 and GL api.
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ IM_ASSERT(platform_io.Renderer_CreateWindow == NULL);
+ IM_ASSERT(platform_io.Renderer_DestroyWindow == NULL);
+ IM_ASSERT(platform_io.Renderer_SwapBuffers == NULL);
+ IM_ASSERT(platform_io.Platform_RenderWindow == NULL);
+ platform_io.Renderer_CreateWindow = Hook_Renderer_CreateWindow;
+ platform_io.Renderer_DestroyWindow = Hook_Renderer_DestroyWindow;
+ platform_io.Renderer_SwapBuffers = Hook_Renderer_SwapBuffers;
+ platform_io.Platform_RenderWindow = Hook_Platform_RenderWindow;
+ }
+
// Load Fonts
// - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
// - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
@@ -163,6 +223,16 @@
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+ // Update and Render additional Platform Windows
+ if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ ImGui::UpdatePlatformWindows();
+ ImGui::RenderPlatformWindowsDefault();
+
+ // Restore the OpenGL rendering context to the main window DC, since platform windows might have changed it.
+ wglMakeCurrent(g_MainWindow.hDC, g_hRC);
+ }
+
// Present
::SwapBuffers(g_MainWindow.hDC);
}
diff --git a/imgui.cpp b/imgui.cpp
index ac76ddd..e091aa7 100644
--- a/imgui.cpp
+++ b/imgui.cpp
@@ -91,6 +91,7 @@
// [SECTION] SETTINGS
// [SECTION] LOCALIZATION
// [SECTION] VIEWPORTS, PLATFORM WINDOWS
+// [SECTION] DOCKING
// [SECTION] PLATFORM DEPENDENT HELPERS
// [SECTION] METRICS/DEBUGGER WINDOW
// [SECTION] DEBUG LOG WINDOW
@@ -430,6 +431,13 @@
When you are not sure about an old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all imgui files.
You can read releases logs https://github.com/ocornut/imgui/releases for more details.
+(Docking/Viewport Branch)
+ - 2024/XX/XX (1.XXXX) - when multi-viewports are enabled, all positions will be in your natural OS coordinates space. It means that:
+ - reference to hard-coded positions such as in SetNextWindowPos(ImVec2(0,0)) are probably not what you want anymore.
+ you may use GetMainViewport()->Pos to offset hard-coded positions, e.g. SetNextWindowPos(GetMainViewport()->Pos)
+ - likewise io.MousePos and GetMousePos() will use OS coordinates.
+ If you query mouse positions to interact with non-imgui coordinates you will need to offset them, e.g. subtract GetWindowViewport()->Pos.
+
- 2024/08/23 (1.91.1) - renamed ImGuiChildFlags_Border to ImGuiChildFlags_Borders for consistency. kept inline redirection flag.
- 2024/08/22 (1.91.1) - moved some functions from ImGuiIO to ImGuiPlatformIO structure:
- io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn + changed 'void* user_data' to 'ImGuiContext* ctx'. Pull your user data from platform_io.ClipboardUserData.
@@ -489,6 +497,9 @@
- new: IsMouseClicked(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id = 0);
for various reasons those changes makes sense. They are being made because making some of those API public.
only past users of imgui_internal.h with the extra parameters will be affected. Added asserts for valid flags in various functions to detect _some_ misuses, BUT NOT ALL.
+ - 2024/05/21 (1.90.7) - docking: changed signature of DockSpaceOverViewport() to add explicit dockspace id if desired. pass 0 to use old behavior. (#7611)
+ - old: DockSpaceOverViewport(const ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, ...);
+ - new: DockSpaceOverViewport(ImGuiID dockspace_id = 0, const ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, ...);
- 2024/05/16 (1.90.7) - inputs: on macOS X, Cmd and Ctrl keys are now automatically swapped by io.AddKeyEvent() as this naturally align with how macOS X uses those keys.
- it shouldn't really affect you unless you had custom shortcut swapping in place for macOS X apps.
- removed ImGuiMod_Shortcut which was previously dynamically remapping to Ctrl or Cmd/Super. It is now unnecessary to specific cross-platform idiomatic shortcuts. (#2343, #4084, #5923, #456)
@@ -1138,6 +1149,9 @@
// Tooltip offset
static const ImVec2 TOOLTIP_DEFAULT_OFFSET = ImVec2(16, 10); // Multiplied by g.Style.MouseCursorScale
+// Docking
+static const float DOCKING_TRANSPARENT_PAYLOAD_ALPHA = 0.50f; // For use with io.ConfigDockingTransparentPayload. Apply to Viewport _or_ WindowBg in host viewport.
+
//-------------------------------------------------------------------------
// [SECTION] FORWARD DECLARATIONS
//-------------------------------------------------------------------------
@@ -1212,7 +1226,18 @@
// Viewports
const ImGuiID IMGUI_VIEWPORT_DEFAULT_ID = 0x11111111; // Using an arbitrary constant instead of e.g. ImHashStr("ViewportDefault", 0); so it's easier to spot in the debugger. The exact value doesn't matter.
+static ImGuiViewportP* AddUpdateViewport(ImGuiWindow* window, ImGuiID id, const ImVec2& platform_pos, const ImVec2& size, ImGuiViewportFlags flags);
+static void DestroyViewport(ImGuiViewportP* viewport);
static void UpdateViewportsNewFrame();
+static void UpdateViewportsEndFrame();
+static void WindowSelectViewport(ImGuiWindow* window);
+static void WindowSyncOwnedViewport(ImGuiWindow* window, ImGuiWindow* parent_window_in_stack);
+static bool UpdateTryMergeWindowIntoHostViewport(ImGuiWindow* window, ImGuiViewportP* host_viewport);
+static bool UpdateTryMergeWindowIntoHostViewports(ImGuiWindow* window);
+static bool GetWindowAlwaysWantOwnViewport(ImGuiWindow* window);
+static int FindPlatformMonitorForPos(const ImVec2& pos);
+static int FindPlatformMonitorForRect(const ImRect& r);
+static void UpdateViewportPlatformMonitor(ImGuiViewportP* viewport);
}
@@ -1305,6 +1330,7 @@
SeparatorTextPadding = ImVec2(20.0f,3.f);// Horizontal offset of text from each edge of the separator + spacing on other axis. Generally small values. .y is recommended to be == FramePadding.y.
DisplayWindowPadding = ImVec2(19,19); // Window position are clamped to be visible within the display area or monitors by at least this amount. Only applies to regular windows.
DisplaySafeAreaPadding = ImVec2(3,3); // If you cannot see the edge of your screen (e.g. on a TV) increase the safe area padding. Covers popups/tooltips as well regular windows.
+ DockingSeparatorSize = 2.0f; // Thickness of resizing border between docked windows
MouseCursorScale = 1.0f; // Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). May be removed later.
AntiAliasedLines = true; // Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU.
AntiAliasedLinesUseTex = true; // Enable anti-aliased lines/borders using textures where possible. Require backend to render with bilinear filtering (NOT point/nearest filtering).
@@ -1349,6 +1375,7 @@
TabMinWidthForCloseButton = (TabMinWidthForCloseButton != FLT_MAX) ? ImTrunc(TabMinWidthForCloseButton * scale_factor) : FLT_MAX;
TabBarOverlineSize = ImTrunc(TabBarOverlineSize * scale_factor);
SeparatorTextPadding = ImTrunc(SeparatorTextPadding * scale_factor);
+ DockingSeparatorSize = ImTrunc(DockingSeparatorSize * scale_factor);
DisplayWindowPadding = ImTrunc(DisplayWindowPadding * scale_factor);
DisplaySafeAreaPadding = ImTrunc(DisplaySafeAreaPadding * scale_factor);
MouseCursorScale = ImTrunc(MouseCursorScale * scale_factor);
@@ -1380,6 +1407,18 @@
FontAllowUserScaling = false;
DisplayFramebufferScale = ImVec2(1.0f, 1.0f);
+ // Docking options (when ImGuiConfigFlags_DockingEnable is set)
+ ConfigDockingNoSplit = false;
+ ConfigDockingWithShift = false;
+ ConfigDockingAlwaysTabBar = false;
+ ConfigDockingTransparentPayload = false;
+
+ // Viewport options (when ImGuiConfigFlags_ViewportsEnable is set)
+ ConfigViewportsNoAutoMerge = false;
+ ConfigViewportsNoTaskBarIcon = false;
+ ConfigViewportsNoDecoration = true;
+ ConfigViewportsNoDefaultParent = false;
+
// Miscellaneous options
MouseDrawCursor = false;
#ifdef __APPLE__
@@ -1758,6 +1797,27 @@
g.InputEventsNextMouseSource = source;
}
+void ImGuiIO::AddMouseViewportEvent(ImGuiID viewport_id)
+{
+ IM_ASSERT(Ctx != NULL);
+ ImGuiContext& g = *Ctx;
+ //IM_ASSERT(g.IO.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport);
+ if (!AppAcceptingEvents)
+ return;
+
+ // Filter duplicate
+ const ImGuiInputEvent* latest_event = FindLatestInputEvent(&g, ImGuiInputEventType_MouseViewport);
+ const ImGuiID latest_viewport_id = latest_event ? latest_event->MouseViewport.HoveredViewportID : g.IO.MouseHoveredViewport;
+ if (latest_viewport_id == viewport_id)
+ return;
+
+ ImGuiInputEvent e;
+ e.Type = ImGuiInputEventType_MouseViewport;
+ e.Source = ImGuiInputSource_Mouse;
+ e.MouseViewport.HoveredViewportID = viewport_id;
+ g.InputEventsQueue.push_back(e);
+}
+
void ImGuiIO::AddFocusEvent(bool focused)
{
IM_ASSERT(Ctx != NULL);
@@ -3282,6 +3342,11 @@
}
}
+static const ImGuiCol GWindowDockStyleColors[ImGuiWindowDockStyleCol_COUNT] =
+{
+ ImGuiCol_Text, ImGuiCol_TabHovered, ImGuiCol_Tab, ImGuiCol_TabSelected, ImGuiCol_TabSelectedOverline, ImGuiCol_TabDimmed, ImGuiCol_TabDimmedSelected, ImGuiCol_TabDimmedSelectedOverline,
+};
+
static const ImGuiDataVarInfo GStyleVarInfo[] =
{
{ ImGuiDataType_Float, 1, (ImU32)offsetof(ImGuiStyle, Alpha) }, // ImGuiStyleVar_Alpha
@@ -3317,6 +3382,7 @@
{ ImGuiDataType_Float, 1, (ImU32)offsetof(ImGuiStyle, SeparatorTextBorderSize)}, // ImGuiStyleVar_SeparatorTextBorderSize
{ ImGuiDataType_Float, 2, (ImU32)offsetof(ImGuiStyle, SeparatorTextAlign) }, // ImGuiStyleVar_SeparatorTextAlign
{ ImGuiDataType_Float, 2, (ImU32)offsetof(ImGuiStyle, SeparatorTextPadding) }, // ImGuiStyleVar_SeparatorTextPadding
+ { ImGuiDataType_Float, 1, (ImU32)offsetof(ImGuiStyle, DockingSeparatorSize) }, // ImGuiStyleVar_DockingSeparatorSize
};
const ImGuiDataVarInfo* ImGui::GetStyleVarInfo(ImGuiStyleVar idx)
@@ -3448,6 +3514,8 @@
case ImGuiCol_TabDimmed: return "TabDimmed";
case ImGuiCol_TabDimmedSelected: return "TabDimmedSelected";
case ImGuiCol_TabDimmedSelectedOverline: return "TabDimmedSelectedOverline";
+ case ImGuiCol_DockingPreview: return "DockingPreview";
+ case ImGuiCol_DockingEmptyBg: return "DockingEmptyBg";
case ImGuiCol_PlotLines: return "PlotLines";
case ImGuiCol_PlotLinesHovered: return "PlotLinesHovered";
case ImGuiCol_PlotHistogram: return "PlotHistogram";
@@ -3709,7 +3777,7 @@
if (!font_atlas->GetMouseCursorTexData(mouse_cursor, &offset, &size, &uv[0], &uv[2]))
continue;
const ImVec2 pos = base_pos - offset;
- const float scale = base_scale;
+ const float scale = base_scale * viewport->DpiScale;
if (!viewport->GetMainRect().Overlaps(ImRect(pos, pos + ImVec2(size.x + 2, size.y + 2) * scale)))
continue;
ImDrawList* draw_list = GetForegroundDrawList(viewport);
@@ -3791,7 +3859,10 @@
{ ImGuiLocKey_WindowingMainMenuBar, "(Main menu bar)" },
{ ImGuiLocKey_WindowingPopup, "(Popup)" },
{ ImGuiLocKey_WindowingUntitled, "(Untitled)" },
- { ImGuiLocKey_CopyLink, "Copy Link###CopyLink" },
+ { ImGuiLocKey_CopyLink, "Copy Link###CopyLink" },
+ { ImGuiLocKey_DockingHideTabBar, "Hide tab bar###HideTabBar" },
+ { ImGuiLocKey_DockingHoldShiftToDock, "Hold SHIFT to enable Docking window." },
+ { ImGuiLocKey_DockingDragToUndockOrMoveNode,"Click and drag to move or undock whole node." },
};
void ImGui::Initialize()
@@ -3825,8 +3896,13 @@
// Create default viewport
ImGuiViewportP* viewport = IM_NEW(ImGuiViewportP)();
viewport->ID = IMGUI_VIEWPORT_DEFAULT_ID;
+ viewport->Idx = 0;
+ viewport->PlatformWindowCreated = true;
+ viewport->Flags = ImGuiViewportFlags_OwnedByApp;
g.Viewports.push_back(viewport);
g.TempBuffer.resize(1024 * 3 + 1, 0);
+ g.ViewportCreatedCount++;
+ g.PlatformIO.Viewports.push_back(g.Viewports[0]);
// Build KeysMayBeCharInput[] lookup table (1 bool per named key)
for (ImGuiKey key = ImGuiKey_NamedKey_BEGIN; key < ImGuiKey_NamedKey_END; key = (ImGuiKey)(key + 1))
@@ -3837,6 +3913,8 @@
g.KeysMayBeCharInput.SetBit(key);
#ifdef IMGUI_HAS_DOCK
+ // Initialize Docking
+ DockContextInitialize(&g);
#endif
g.Initialized = true;
@@ -3866,6 +3944,12 @@
if (g.SettingsLoaded && g.IO.IniFilename != NULL)
SaveIniSettingsToDisk(g.IO.IniFilename);
+ // Destroy platform windows
+ DestroyPlatformWindows();
+
+ // Shutdown extensions
+ DockContextShutdown(&g);
+
CallContextHooks(&g, ImGuiContextHookType_Shutdown);
// Clear everything else
@@ -3889,6 +3973,7 @@
g.BeginPopupStack.clear();
g.TreeNodeStack.clear();
+ g.CurrentViewport = g.MouseViewport = g.MouseLastHoveredViewport = NULL;
g.Viewports.clear_delete();
g.TabBars.Clear();
@@ -3971,21 +4056,27 @@
NameBufLen = (int)strlen(name) + 1;
ID = ImHashStr(name);
IDStack.push_back(ID);
+ ViewportAllowPlatformMonitorExtend = -1;
+ ViewportPos = ImVec2(FLT_MAX, FLT_MAX);
MoveId = GetID("#MOVE");
+ TabId = GetID("#TAB");
ScrollTarget = ImVec2(FLT_MAX, FLT_MAX);
ScrollTargetCenterRatio = ImVec2(0.5f, 0.5f);
AutoFitFramesX = AutoFitFramesY = -1;
AutoPosLastDirection = ImGuiDir_None;
- SetWindowPosAllowFlags = SetWindowSizeAllowFlags = SetWindowCollapsedAllowFlags = 0;
+ SetWindowPosAllowFlags = SetWindowSizeAllowFlags = SetWindowCollapsedAllowFlags = SetWindowDockAllowFlags = 0;
SetWindowPosVal = SetWindowPosPivot = ImVec2(FLT_MAX, FLT_MAX);
LastFrameActive = -1;
+ LastFrameJustFocused = -1;
LastTimeActive = -1.0f;
- FontWindowScale = 1.0f;
+ FontWindowScale = FontDpiScale = 1.0f;
SettingsOffset = -1;
+ DockOrder = -1;
DrawList = &DrawListInst;
DrawList->_Data = &Ctx->DrawListSharedData;
DrawList->_OwnerName = Name;
NavPreferredScoringPosRel[0] = NavPreferredScoringPosRel[1] = ImVec2(FLT_MAX, FLT_MAX);
+ IM_PLACEMENT_NEW(&WindowClass) ImGuiWindowClass();
}
ImGuiWindow::~ImGuiWindow()
@@ -4000,7 +4091,6 @@
ImGuiContext& g = *GImGui;
g.CurrentWindow = window;
g.CurrentTable = window && window->DC.CurrentTableIdx != -1 ? g.Tables.GetByIndex(window->DC.CurrentTableIdx) : NULL;
- g.CurrentDpiScale = 1.0f; // FIXME-DPI: WIP this is modified in docking
if (window)
{
g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
@@ -4149,8 +4239,8 @@
// FIXME-OPT: This could be cached/stored within the window.
ImGuiContext& g = *GImGui;
if (g.NavWindow)
- if (ImGuiWindow* focused_root_window = g.NavWindow->RootWindow)
- if (focused_root_window->WasActive && focused_root_window != window->RootWindow)
+ if (ImGuiWindow* focused_root_window = g.NavWindow->RootWindowDockTree)
+ if (focused_root_window->WasActive && focused_root_window != window->RootWindowDockTree)
{
// For the purpose of those flags we differentiate "standard popup" from "modal popup"
// NB: The 'else' is important because Modal windows are also Popups.
@@ -4165,6 +4255,12 @@
if (!IsWindowWithinBeginStackOf(window->RootWindow, focused_root_window))
return false;
}
+
+ // Filter by viewport
+ if (window->Viewport != g.MouseViewport)
+ if (g.MovingWindow == NULL || window->RootWindowDockTree != g.MovingWindow->RootWindowDockTree)
+ return false;
+
return true;
}
@@ -4215,7 +4311,7 @@
if (flags & ImGuiHoveredFlags_ForTooltip)
flags = ApplyHoverFlagsForTooltip(flags, g.Style.HoverFlagsForTooltipMouse);
- IM_ASSERT((flags & (ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_NoPopupHierarchy)) == 0); // Flags not supported by this function
+ IM_ASSERT((flags & (ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_DockHierarchy)) == 0); // Flags not supported by this function
// Done with rectangle culling so we can perform heavier checks now
// Test if we are hovering the right window (our window could be behind another window)
@@ -4231,7 +4327,7 @@
const ImGuiID id = g.LastItemData.ID;
if ((flags & ImGuiHoveredFlags_AllowWhenBlockedByActiveItem) == 0)
if (g.ActiveId != 0 && g.ActiveId != id && !g.ActiveIdAllowOverlap)
- if (g.ActiveId != window->MoveId)
+ if (g.ActiveId != window->MoveId && g.ActiveId != window->TabId)
return false;
// Test if interactions on this window are blocked by an active popup or modal.
@@ -4533,26 +4629,18 @@
ImDrawList* ImGui::GetBackgroundDrawList(ImGuiViewport* viewport)
{
+ if (viewport == NULL)
+ viewport = GImGui->CurrentWindow->Viewport;
return GetViewportBgFgDrawList((ImGuiViewportP*)viewport, 0, "##Background");
}
-ImDrawList* ImGui::GetBackgroundDrawList()
-{
- ImGuiContext& g = *GImGui;
- return GetBackgroundDrawList(g.Viewports[0]);
-}
-
ImDrawList* ImGui::GetForegroundDrawList(ImGuiViewport* viewport)
{
+ if (viewport == NULL)
+ viewport = GImGui->CurrentWindow->Viewport;
return GetViewportBgFgDrawList((ImGuiViewportP*)viewport, 1, "##Foreground");
}
-ImDrawList* ImGui::GetForegroundDrawList()
-{
- ImGuiContext& g = *GImGui;
- return GetForegroundDrawList(g.Viewports[0]);
-}
-
ImDrawListSharedData* ImGui::GetDrawListSharedData()
{
return &GImGui->DrawListSharedData;
@@ -4567,17 +4655,43 @@
FocusWindow(window);
SetActiveID(window->MoveId, window);
g.NavDisableHighlight = true;
- g.ActiveIdClickOffset = g.IO.MouseClickedPos[0] - window->RootWindow->Pos;
+ g.ActiveIdClickOffset = g.IO.MouseClickedPos[0] - window->RootWindowDockTree->Pos;
g.ActiveIdNoClearOnFocusLoss = true;
SetActiveIdUsingAllKeyboardKeys();
bool can_move_window = true;
- if ((window->Flags & ImGuiWindowFlags_NoMove) || (window->RootWindow->Flags & ImGuiWindowFlags_NoMove))
+ if ((window->Flags & ImGuiWindowFlags_NoMove) || (window->RootWindowDockTree->Flags & ImGuiWindowFlags_NoMove))
can_move_window = false;
+ if (ImGuiDockNode* node = window->DockNodeAsHost)
+ if (node->VisibleWindow && (node->VisibleWindow->Flags & ImGuiWindowFlags_NoMove))
+ can_move_window = false;
if (can_move_window)
g.MovingWindow = window;
}
+// We use 'undock == false' when dragging from title bar to allow moving groups of floating nodes without undocking them.
+void ImGui::StartMouseMovingWindowOrNode(ImGuiWindow* window, ImGuiDockNode* node, bool undock)
+{
+ ImGuiContext& g = *GImGui;
+ bool can_undock_node = false;
+ if (undock && node != NULL && node->VisibleWindow && (node->VisibleWindow->Flags & ImGuiWindowFlags_NoMove) == 0 && (node->MergedFlags & ImGuiDockNodeFlags_NoUndocking) == 0)
+ {
+ // Can undock if:
+ // - part of a hierarchy with more than one visible node (if only one is visible, we'll just move the root window)
+ // - part of a dockspace node hierarchy: so we can undock the last single visible node too (trivia: undocking from a fixed/central node will create a new node and copy windows)
+ ImGuiDockNode* root_node = DockNodeGetRootNode(node);
+ if (root_node->OnlyNodeWithWindows != node || root_node->CentralNode != NULL) // -V1051 PVS-Studio thinks node should be root_node and is wrong about that.
+ can_undock_node = true;
+ }
+
+ const bool clicked = IsMouseClicked(0);
+ const bool dragging = IsMouseDragging(0);
+ if (can_undock_node && dragging)
+ DockContextQueueUndockNode(&g, node); // Will lead to DockNodeStartMouseMovingWindow() -> StartMouseMovingWindow() being called next frame
+ else if (!can_undock_node && (clicked || dragging) && g.MovingWindow != window)
+ StartMouseMovingWindow(window);
+}
+
// Handle mouse moving window
// Note: moving window with the navigation keys (Square + d-pad / CTRL+TAB + Arrows) are processed in NavUpdateWindowing()
// FIXME: We don't have strong guarantee that g.MovingWindow stay synched with g.ActiveId == g.MovingWindow->MoveId.
@@ -4591,16 +4705,43 @@
// We actually want to move the root window. g.MovingWindow == window we clicked on (could be a child window).
// We track it to preserve Focus and so that generally ActiveIdWindow == MovingWindow and ActiveId == MovingWindow->MoveId for consistency.
KeepAliveID(g.ActiveId);
- IM_ASSERT(g.MovingWindow && g.MovingWindow->RootWindow);
- ImGuiWindow* moving_window = g.MovingWindow->RootWindow;
- if (g.IO.MouseDown[0] && IsMousePosValid(&g.IO.MousePos))
+ IM_ASSERT(g.MovingWindow && g.MovingWindow->RootWindowDockTree);
+ ImGuiWindow* moving_window = g.MovingWindow->RootWindowDockTree;
+
+ // When a window stop being submitted while being dragged, it may will its viewport until next Begin()
+ const bool window_disappared = (!moving_window->WasActive && !moving_window->Active);
+ if (g.IO.MouseDown[0] && IsMousePosValid(&g.IO.MousePos) && !window_disappared)
{
ImVec2 pos = g.IO.MousePos - g.ActiveIdClickOffset;
- SetWindowPos(moving_window, pos, ImGuiCond_Always);
+ if (moving_window->Pos.x != pos.x || moving_window->Pos.y != pos.y)
+ {
+ SetWindowPos(moving_window, pos, ImGuiCond_Always);
+ if (moving_window->Viewport && moving_window->ViewportOwned) // Synchronize viewport immediately because some overlays may relies on clipping rectangle before we Begin() into the window.
+ {
+ moving_window->Viewport->Pos = pos;
+ moving_window->Viewport->UpdateWorkRect();
+ }
+ }
FocusWindow(g.MovingWindow);
}
else
{
+ if (!window_disappared)
+ {
+ // Try to merge the window back into the main viewport.
+ // This works because MouseViewport should be != MovingWindow->Viewport on release (as per code in UpdateViewports)
+ if (g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable)
+ UpdateTryMergeWindowIntoHostViewport(moving_window, g.MouseViewport);
+
+ // Restore the mouse viewport so that we don't hover the viewport _under_ the moved window during the frame we released the mouse button.
+ if (moving_window->Viewport && !IsDragDropPayloadBeingAccepted())
+ g.MouseViewport = moving_window->Viewport;
+
+ // Clear the NoInput window flag set by the Viewport system
+ if (moving_window->Viewport)
+ moving_window->Viewport->Flags &= ~ImGuiViewportFlags_NoInputs;
+ }
+
g.MovingWindow = NULL;
ClearActiveID();
}
@@ -4630,7 +4771,7 @@
return;
// Click on empty space to focus window and start moving
- // (after we're done with all our widgets)
+ // (after we're done with all our widgets, so e.g. clicking on docking tab-bar which have set HoveredId already and not get us here!)
if (g.IO.MouseClicked[0])
{
// Handle the edge case of a popup being closed while clicking in its empty space.
@@ -4644,7 +4785,7 @@
// Cancel moving if clicked outside of title bar
if (g.IO.ConfigWindowsMoveFromTitleBarOnly)
- if (!(root_window->Flags & ImGuiWindowFlags_NoTitleBar))
+ if (!(root_window->Flags & ImGuiWindowFlags_NoTitleBar) || root_window->DockIsActive)
if (!root_window->TitleBarRect().Contains(g.IO.MouseClickedPos[0]))
g.MovingWindow = NULL;
@@ -4672,6 +4813,29 @@
}
}
+// This is called during NewFrame()->UpdateViewportsNewFrame() only.
+// Need to keep in sync with SetWindowPos()
+static void TranslateWindow(ImGuiWindow* window, const ImVec2& delta)
+{
+ window->Pos += delta;
+ window->ClipRect.Translate(delta);
+ window->OuterRectClipped.Translate(delta);
+ window->InnerRect.Translate(delta);
+ window->DC.CursorPos += delta;
+ window->DC.CursorStartPos += delta;
+ window->DC.CursorMaxPos += delta;
+ window->DC.IdealMaxPos += delta;
+}
+
+static void ScaleWindow(ImGuiWindow* window, float scale)
+{
+ ImVec2 origin = window->Viewport->Pos;
+ window->Pos = ImFloor((window->Pos - origin) * scale + origin);
+ window->Size = ImTrunc(window->Size * scale);
+ window->SizeFull = ImTrunc(window->SizeFull * scale);
+ window->ContentSize = ImTrunc(window->ContentSize * scale);
+}
+
static bool IsWindowActiveAndVisible(ImGuiWindow* window)
{
return (window->Active) && (!window->Hidden);
@@ -4693,11 +4857,12 @@
// - We also support the moved window toggling the NoInputs flag after moving has started in order to be able to detect windows below it, which is useful for e.g. docking mechanisms.
bool clear_hovered_windows = false;
FindHoveredWindowEx(g.IO.MousePos, false, &g.HoveredWindow, &g.HoveredWindowUnderMovingWindow);
+ IM_ASSERT(g.HoveredWindow == NULL || g.HoveredWindow == g.MovingWindow || g.HoveredWindow->Viewport == g.MouseViewport);
g.HoveredWindowBeforeClear = g.HoveredWindow;
// Modal windows prevents mouse from hovering behind them.
ImGuiWindow* modal_window = GetTopMostPopupModal();
- if (modal_window && g.HoveredWindow && !IsWindowWithinBeginStackOf(g.HoveredWindow->RootWindow, modal_window))
+ if (modal_window && g.HoveredWindow && !IsWindowWithinBeginStackOf(g.HoveredWindow->RootWindow, modal_window)) // FIXME-MERGE: RootWindowDockTree ?
clear_hovered_windows = true;
// Disabled mouse hovering (we don't currently clear MousePos, we could)
@@ -4792,7 +4957,9 @@
CallContextHooks(&g, ImGuiContextHookType_NewFramePre);
// Check and assert for various common IO and Configuration mistakes
+ g.ConfigFlagsLastFrame = g.ConfigFlagsCurrFrame;
ErrorCheckNewFrameSanityChecks();
+ g.ConfigFlagsCurrFrame = g.IO.ConfigFlags;
// Load settings on first frame, save settings when modified (after a delay)
UpdateSettings();
@@ -4819,6 +4986,7 @@
UpdateViewportsNewFrame();
// Setup current font and draw list shared data
+ // FIXME-VIEWPORT: the concept of a single ClipRectFullscreen is not ideal!
g.IO.Fonts->Locked = true;
SetupDrawListSharedData();
SetCurrentFont(GetDefaultFont());
@@ -4826,7 +4994,10 @@
// Mark rendering data as invalid to prevent user who may have a handle on it to use it.
for (ImGuiViewportP* viewport : g.Viewports)
+ {
+ viewport->DrawData = NULL;
viewport->DrawDataP.Valid = false;
+ }
// Drag and drop keep the source ID alive so even if the source disappear our state is consistent
if (g.DragDropActive && g.DragDropPayload.SourceId == g.ActiveId)
@@ -4929,6 +5100,10 @@
// Update mouse input state
UpdateMouseInputs();
+ // Undocking
+ // (needs to be before UpdateMouseMovingWindowNewFrame so the window is already offset and following the mouse on the detaching frame)
+ DockContextNewFrameUpdateUndocking(&g);
+
// Find hovered window
// (needs to be before UpdateMouseMovingWindowNewFrame so we fill g.HoveredWindowUnderMovingWindow on the mouse release frame)
UpdateHoveredWindowAndCaptureFlags();
@@ -4992,6 +5167,9 @@
g.CurrentItemFlags = g.ItemFlagsStack.back();
g.GroupStack.resize(0);
+ // Docking
+ DockContextNewFrameUpdateDocking(&g);
+
// [DEBUG] Update debug features
#ifndef IMGUI_DISABLE_DEBUG_TOOLS
UpdateDebugToolItemPicker();
@@ -5061,7 +5239,8 @@
static void AddWindowToDrawData(ImGuiWindow* window, int layer)
{
ImGuiContext& g = *GImGui;
- ImGuiViewportP* viewport = g.Viewports[0];
+ ImGuiViewportP* viewport = window->Viewport;
+ IM_ASSERT(viewport != NULL);
g.IO.MetricsRenderWindows++;
if (window->DrawList->_Splitter._Count > 1)
window->DrawList->ChannelsMerge(); // Merge if user forgot to merge back. Also required in Docking branch for ImGuiWindowFlags_DockNodeHost windows.
@@ -5105,17 +5284,25 @@
ImGuiIO& io = ImGui::GetIO();
ImDrawData* draw_data = &viewport->DrawDataP;
+ viewport->DrawData = draw_data; // Make publicly accessible
viewport->DrawDataBuilder.Layers[0] = &draw_data->CmdLists;
viewport->DrawDataBuilder.Layers[1] = &viewport->DrawDataBuilder.LayerData1;
viewport->DrawDataBuilder.Layers[0]->resize(0);
viewport->DrawDataBuilder.Layers[1]->resize(0);
+ // When minimized, we report draw_data->DisplaySize as zero to be consistent with non-viewport mode,
+ // and to allow applications/backends to easily skip rendering.
+ // FIXME: Note that we however do NOT attempt to report "zero drawlist / vertices" into the ImDrawData structure.
+ // This is because the work has been done already, and its wasted! We should fix that and add optimizations for
+ // it earlier in the pipeline, rather than pretend to hide the data at the end of the pipeline.
+ const bool is_minimized = (viewport->Flags & ImGuiViewportFlags_IsMinimized) != 0;
+
draw_data->Valid = true;
draw_data->CmdListsCount = 0;
draw_data->TotalVtxCount = draw_data->TotalIdxCount = 0;
draw_data->DisplayPos = viewport->Pos;
- draw_data->DisplaySize = viewport->Size;
- draw_data->FramebufferScale = io.DisplayFramebufferScale;
+ draw_data->DisplaySize = is_minimized ? ImVec2(0.0f, 0.0f) : viewport->Size;
+ draw_data->FramebufferScale = io.DisplayFramebufferScale; // FIXME-VIEWPORT: This may vary on a per-monitor/viewport basis?
draw_data->OwnerViewport = viewport;
}
@@ -5141,20 +5328,28 @@
window->ClipRect = window->DrawList->_ClipRectStack.back();
}
+static ImGuiWindow* FindFrontMostVisibleChildWindow(ImGuiWindow* window)
+{
+ for (int n = window->DC.ChildWindows.Size - 1; n >= 0; n--)
+ if (IsWindowActiveAndVisible(window->DC.ChildWindows[n]))
+ return FindFrontMostVisibleChildWindow(window->DC.ChildWindows[n]);
+ return window;
+}
+
static void ImGui::RenderDimmedBackgroundBehindWindow(ImGuiWindow* window, ImU32 col)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
- ImGuiViewportP* viewport = (ImGuiViewportP*)GetMainViewport();
+ ImGuiViewportP* viewport = window->Viewport;
ImRect viewport_rect = viewport->GetMainRect();
// Draw behind window by moving the draw command at the FRONT of the draw list
{
- // We've already called AddWindowToDrawData() which called DrawList->ChannelsMerge() on DockNodeHost windows,
- // and draw list have been trimmed already, hence the explicit recreation of a draw command if missing.
+ // Draw list have been trimmed already, hence the explicit recreation of a draw command if missing.
// FIXME: This is creating complication, might be simpler if we could inject a drawlist in drawdata at a given position and not attempt to manipulate ImDrawCmd order.
- ImDrawList* draw_list = window->RootWindow->DrawList;
+ ImDrawList* draw_list = window->RootWindowDockTree->DrawList;
+ draw_list->ChannelsMerge();
if (draw_list->CmdBuffer.Size == 0)
draw_list->AddDrawCmd();
draw_list->PushClipRect(viewport_rect.Min - ImVec2(1, 1), viewport_rect.Max + ImVec2(1, 1), false); // FIXME: Need to stricty ensure ImDrawCmd are not merged (ElemCount==6 checks below will verify that)
@@ -5166,6 +5361,18 @@
draw_list->AddDrawCmd(); // We need to create a command as CmdBuffer.back().IdxOffset won't be correct if we append to same command.
draw_list->PopClipRect();
}
+
+ // Draw over sibling docking nodes in a same docking tree
+ if (window->RootWindow->DockIsActive)
+ {
+ ImDrawList* draw_list = FindFrontMostVisibleChildWindow(window->RootWindowDockTree)->DrawList;
+ draw_list->ChannelsMerge();
+ if (draw_list->CmdBuffer.Size == 0)
+ draw_list->AddDrawCmd();
+ draw_list->PushClipRect(viewport_rect.Min, viewport_rect.Max, false);
+ RenderRectFilledWithHole(draw_list, window->RootWindowDockTree->Rect(), window->RootWindow->Rect(), col, 0.0f);// window->RootWindowDockTree->WindowRounding);
+ draw_list->PopClipRect();
+ }
}
ImGuiWindow* ImGui::FindBottomMostVisibleWindowWithinBeginStack(ImGuiWindow* parent_window)
@@ -5185,6 +5392,8 @@
return bottom_most_visible_window;
}
+// Important: AddWindowToDrawData() has not been called yet, meaning DockNodeHost windows needs a DrawList->ChannelsMerge() before usage.
+// We call ChannelsMerge() lazily here at it is faster that doing a full iteration of g.Windows[] prior to calling RenderDimmedBackgrounds().
static void ImGui::RenderDimmedBackgrounds()
{
ImGuiContext& g = *GImGui;
@@ -5196,31 +5405,50 @@
if (!dim_bg_for_modal && !dim_bg_for_window_list)
return;
+ ImGuiViewport* viewports_already_dimmed[2] = { NULL, NULL };
if (dim_bg_for_modal)
{
// Draw dimming behind modal or a begin stack child, whichever comes first in draw order.
ImGuiWindow* dim_behind_window = FindBottomMostVisibleWindowWithinBeginStack(modal_window);
RenderDimmedBackgroundBehindWindow(dim_behind_window, GetColorU32(modal_window->DC.ModalDimBgColor, g.DimBgRatio));
+ viewports_already_dimmed[0] = modal_window->Viewport;
}
else if (dim_bg_for_window_list)
{
// Draw dimming behind CTRL+Tab target window and behind CTRL+Tab UI window
RenderDimmedBackgroundBehindWindow(g.NavWindowingTargetAnim, GetColorU32(ImGuiCol_NavWindowingDimBg, g.DimBgRatio));
+ if (g.NavWindowingListWindow != NULL && g.NavWindowingListWindow->Viewport && g.NavWindowingListWindow->Viewport != g.NavWindowingTargetAnim->Viewport)
+ RenderDimmedBackgroundBehindWindow(g.NavWindowingListWindow, GetColorU32(ImGuiCol_NavWindowingDimBg, g.DimBgRatio));
+ viewports_already_dimmed[0] = g.NavWindowingTargetAnim->Viewport;
+ viewports_already_dimmed[1] = g.NavWindowingListWindow ? g.NavWindowingListWindow->Viewport : NULL;
// Draw border around CTRL+Tab target window
ImGuiWindow* window = g.NavWindowingTargetAnim;
- ImGuiViewport* viewport = GetMainViewport();
+ ImGuiViewport* viewport = window->Viewport;
float distance = g.FontSize;
ImRect bb = window->Rect();
bb.Expand(distance);
if (bb.GetWidth() >= viewport->Size.x && bb.GetHeight() >= viewport->Size.y)
bb.Expand(-distance - 1.0f); // If a window fits the entire viewport, adjust its highlight inward
+ window->DrawList->ChannelsMerge();
if (window->DrawList->CmdBuffer.Size == 0)
window->DrawList->AddDrawCmd();
window->DrawList->PushClipRect(viewport->Pos, viewport->Pos + viewport->Size);
window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(ImGuiCol_NavWindowingHighlight, g.NavWindowingHighlightAlpha), window->WindowRounding, 0, 3.0f);
window->DrawList->PopClipRect();
}
+
+ // Draw dimming background on _other_ viewports than the ones our windows are in
+ for (ImGuiViewportP* viewport : g.Viewports)
+ {
+ if (viewport == viewports_already_dimmed[0] || viewport == viewports_already_dimmed[1])
+ continue;
+ if (modal_window && viewport->Window && IsWindowAbove(viewport->Window, modal_window))
+ continue;
+ ImDrawList* draw_list = GetForegroundDrawList(viewport);
+ const ImU32 dim_bg_col = GetColorU32(dim_bg_for_modal ? ImGuiCol_ModalWindowDimBg : ImGuiCol_NavWindowingDimBg, g.DimBgRatio);
+ draw_list->AddRectFilled(viewport->Pos, viewport->Pos + viewport->Size, dim_bg_col);
+ }
}
// This is normally called by Render(). You may want to call it directly if you want to avoid calling Render() but the gain will be very minimal.
@@ -5242,8 +5470,10 @@
ImGuiPlatformImeData* ime_data = &g.PlatformImeData;
if (g.PlatformIO.Platform_SetImeDataFn != NULL && memcmp(ime_data, &g.PlatformImeDataPrev, sizeof(ImGuiPlatformImeData)) != 0)
{
+ ImGuiViewport* viewport = FindViewportByID(g.PlatformImeViewport);
IMGUI_DEBUG_LOG_IO("[io] Calling Platform_SetImeDataFn(): WantVisible: %d, InputPos (%.2f,%.2f)\n", ime_data->WantVisible, ime_data->InputPos.x, ime_data->InputPos.y);
- ImGuiViewport* viewport = GetMainViewport();
+ if (viewport == NULL)
+ viewport = GetMainViewport();
g.PlatformIO.Platform_SetImeDataFn(&g, viewport, ime_data);
}
@@ -5256,6 +5486,11 @@
// Update navigation: CTRL+Tab, wrap-around requests
NavEndFrame();
+ // Update docking
+ DockContextEndFrame(&g);
+
+ SetCurrentViewport(NULL, NULL);
+
// Drag and Drop: Elapse payload (if delivered, or if source stops being submitted)
if (g.DragDropActive)
{
@@ -5284,6 +5519,9 @@
// Initiate moving window + handle left-click and right-click focus
UpdateMouseMovingWindowEndFrame();
+ // Update user-facing viewport list (g.Viewports -> g.PlatformIO.Viewports after filtering out some)
+ UpdateViewportsEndFrame();
+
// Sort the window list so that all child windows are after their parent
// We cannot do that on FocusWindow() because children may not exist yet
g.WindowsTempSortBuffer.resize(0);
@@ -5342,7 +5580,7 @@
// Add ImDrawList to render
ImGuiWindow* windows_to_render_top_most[2];
- windows_to_render_top_most[0] = (g.NavWindowingTarget && !(g.NavWindowingTarget->Flags & ImGuiWindowFlags_NoBringToFrontOnFocus)) ? g.NavWindowingTarget->RootWindow : NULL;
+ windows_to_render_top_most[0] = (g.NavWindowingTarget && !(g.NavWindowingTarget->Flags & ImGuiWindowFlags_NoBringToFrontOnFocus)) ? g.NavWindowingTarget->RootWindowDockTree : NULL;
windows_to_render_top_most[1] = (g.NavWindowingTarget ? g.NavWindowingListWindow : NULL);
for (ImGuiWindow* window : g.Windows)
{
@@ -5421,8 +5659,15 @@
ImGuiWindow* hovered_window = NULL;
ImGuiWindow* hovered_window_under_moving_window = NULL;
- if (find_first_and_in_any_viewport == false && g.MovingWindow && !(g.MovingWindow->Flags & ImGuiWindowFlags_NoMouseInputs))
- hovered_window = g.MovingWindow;
+ // Special handling for the window being moved: Ignore the mouse viewport check (because it may reset/lose its viewport during the undocking frame)
+ ImGuiViewportP* backup_moving_window_viewport = NULL;
+ if (find_first_and_in_any_viewport == false && g.MovingWindow)
+ {
+ backup_moving_window_viewport = g.MovingWindow->Viewport;
+ g.MovingWindow->Viewport = g.MouseViewport;
+ if (!(g.MovingWindow->Flags & ImGuiWindowFlags_NoMouseInputs))
+ hovered_window = g.MovingWindow;
+ }
ImVec2 padding_regular = g.Style.TouchExtraPadding;
ImVec2 padding_for_resize = g.IO.ConfigWindowsResizeFromEdges ? g.WindowsHoverPadding : padding_regular;
@@ -5434,6 +5679,9 @@
continue;
if (window->Flags & ImGuiWindowFlags_NoMouseInputs)
continue;
+ IM_ASSERT(window->Viewport);
+ if (window->Viewport != g.MouseViewport)
+ continue;
// Using the clipped AABB, a child window will typically be clipped by its parent (not always)
ImVec2 hit_padding = (window->Flags & (ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize)) ? padding_regular : padding_for_resize;
@@ -5460,7 +5708,7 @@
if (hovered_window == NULL)
hovered_window = window;
IM_MSVC_WARNING_SUPPRESS(28182); // [Static Analyzer] Dereferencing NULL pointer.
- if (hovered_window_under_moving_window == NULL && (!g.MovingWindow || window->RootWindow != g.MovingWindow->RootWindow))
+ if (hovered_window_under_moving_window == NULL && (!g.MovingWindow || window->RootWindowDockTree != g.MovingWindow->RootWindowDockTree))
hovered_window_under_moving_window = window;
if (hovered_window && hovered_window_under_moving_window)
break;
@@ -5470,6 +5718,8 @@
*out_hovered_window = hovered_window;
if (out_hovered_window_under_moving_window != NULL)
*out_hovered_window_under_moving_window = hovered_window_under_moving_window;
+ if (find_first_and_in_any_viewport == false && g.MovingWindow)
+ g.MovingWindow->Viewport = backup_moving_window_viewport;
}
bool ImGui::IsItemActive()
@@ -5509,6 +5759,13 @@
ImGuiContext& g = *GImGui;
if (g.NavId != g.LastItemData.ID || g.NavId == 0)
return false;
+
+ // Special handling for the dummy item after Begin() which represent the title bar or tab.
+ // When the window is collapsed (SkipItems==true) that last item will never be overwritten so we need to detect the case.
+ ImGuiWindow* window = g.CurrentWindow;
+ if (g.LastItemData.ID == window->ID && window->WriteAccessed)
+ return false;
+
return true;
}
@@ -5669,7 +5926,7 @@
child_flags &= ~ImGuiChildFlags_ResizeY;
// Set window flags
- window_flags |= ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoTitleBar;
+ window_flags |= ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoDocking;
window_flags |= (parent_window->Flags & ImGuiWindowFlags_NoMove); // Inherit the NoMove flag
if (child_flags & (ImGuiChildFlags_AutoResizeX | ImGuiChildFlags_AutoResizeY | ImGuiChildFlags_AlwaysAutoResize))
window_flags |= ImGuiWindowFlags_AlwaysAutoResize;
@@ -5799,6 +6056,7 @@
window->SetWindowPosAllowFlags = enabled ? (window->SetWindowPosAllowFlags | flags) : (window->SetWindowPosAllowFlags & ~flags);
window->SetWindowSizeAllowFlags = enabled ? (window->SetWindowSizeAllowFlags | flags) : (window->SetWindowSizeAllowFlags & ~flags);
window->SetWindowCollapsedAllowFlags = enabled ? (window->SetWindowCollapsedAllowFlags | flags) : (window->SetWindowCollapsedAllowFlags & ~flags);
+ window->SetWindowDockAllowFlags = enabled ? (window->SetWindowDockAllowFlags | flags) : (window->SetWindowDockAllowFlags & ~flags);
}
ImGuiWindow* ImGui::FindWindowByID(ImGuiID id)
@@ -5815,10 +6073,19 @@
static void ApplyWindowSettings(ImGuiWindow* window, ImGuiWindowSettings* settings)
{
- window->Pos = ImTrunc(ImVec2(settings->Pos.x, settings->Pos.y));
+ const ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+ window->ViewportPos = main_viewport->Pos;
+ if (settings->ViewportId)
+ {
+ window->ViewportId = settings->ViewportId;
+ window->ViewportPos = ImVec2(settings->ViewportPos.x, settings->ViewportPos.y);
+ }
+ window->Pos = ImTrunc(ImVec2(settings->Pos.x + window->ViewportPos.x, settings->Pos.y + window->ViewportPos.y));
if (settings->Size.x > 0 && settings->Size.y > 0)
window->Size = window->SizeFull = ImTrunc(ImVec2(settings->Size.x, settings->Size.y));
window->Collapsed = settings->Collapsed;
+ window->DockId = settings->DockId;
+ window->DockOrder = settings->DockOrder;
}
static void UpdateWindowInFocusOrderList(ImGuiWindow* window, bool just_created, ImGuiWindowFlags new_flags)
@@ -5851,7 +6118,8 @@
const ImGuiViewport* main_viewport = ImGui::GetMainViewport();
window->Pos = main_viewport->Pos + ImVec2(60, 60);
window->Size = window->SizeFull = ImVec2(0, 0);
- window->SetWindowPosAllowFlags = window->SetWindowSizeAllowFlags = window->SetWindowCollapsedAllowFlags = ImGuiCond_Always | ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing;
+ window->ViewportPos = main_viewport->Pos;
+ window->SetWindowPosAllowFlags = window->SetWindowSizeAllowFlags = window->SetWindowCollapsedAllowFlags = window->SetWindowDockAllowFlags = ImGuiCond_Always | ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing;
if (settings != NULL)
{
@@ -5899,6 +6167,16 @@
return window;
}
+static ImGuiWindow* GetWindowForTitleDisplay(ImGuiWindow* window)
+{
+ return window->DockNodeAsHost ? window->DockNodeAsHost->VisibleWindow : window;
+}
+
+static ImGuiWindow* GetWindowForTitleAndMenuHeight(ImGuiWindow* window)
+{
+ return (window->DockNodeAsHost && window->DockNodeAsHost->VisibleWindow) ? window->DockNodeAsHost->VisibleWindow : window;
+}
+
static inline ImVec2 CalcWindowMinSize(ImGuiWindow* window)
{
// We give windows non-zero minimum size to facilitate understanding problematic cases (e.g. empty popups)
@@ -5918,7 +6196,7 @@
}
// Reduce artifacts with very small windows
- ImGuiWindow* window_for_height = window;
+ ImGuiWindow* window_for_height = GetWindowForTitleAndMenuHeight(window);
size_min.y = ImMax(size_min.y, window_for_height->TitleBarHeight + window_for_height->MenuBarHeight + ImMax(0.0f, g.Style.WindowRounding - 1.0f));
return size_min;
}
@@ -5989,8 +6267,19 @@
{
// Maximum window size is determined by the viewport size or monitor size
ImVec2 size_min = CalcWindowMinSize(window);
- ImVec2 size_max = ((window->Flags & ImGuiWindowFlags_ChildWindow) && !(window->Flags & ImGuiWindowFlags_Popup)) ? ImVec2(FLT_MAX, FLT_MAX) : ImGui::GetMainViewport()->WorkSize - style.DisplaySafeAreaPadding * 2.0f;
- ImVec2 size_auto_fit = ImClamp(size_desired, size_min, size_max);
+ ImVec2 size_max = ImVec2(FLT_MAX, FLT_MAX);
+
+ // Child windows are layed within their parent (unless they are also popups/menus) and thus have no restriction
+ if ((window->Flags & ImGuiWindowFlags_ChildWindow) == 0 || (window->Flags & ImGuiWindowFlags_Popup) != 0)
+ {
+ if (!window->ViewportOwned)
+ size_max = ImGui::GetMainViewport()->WorkSize - style.DisplaySafeAreaPadding * 2.0f;
+ const int monitor_idx = window->ViewportAllowPlatformMonitorExtend;
+ if (monitor_idx >= 0 && monitor_idx < g.PlatformIO.Monitors.Size)
+ size_max = g.PlatformIO.Monitors[monitor_idx].WorkSize - style.DisplaySafeAreaPadding * 2.0f;
+ }
+
+ ImVec2 size_auto_fit = ImClamp(size_desired, size_min, ImMax(size_min, size_max));
// FIXME: CalcWindowAutoFitSize() doesn't take into account that only one axis may be auto-fit when calculating scrollbars,
// we may need to compute/store three variants of size_auto_fit, for x/y/xy.
@@ -6027,7 +6316,7 @@
{
if (window->Flags & (ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_Popup))
return ImGuiCol_PopupBg;
- if (window->Flags & ImGuiWindowFlags_ChildWindow)
+ if ((window->Flags & ImGuiWindowFlags_ChildWindow) && !window->DockIsActive)
return ImGuiCol_ChildBg;
return ImGuiCol_WindowBg;
}
@@ -6093,7 +6382,7 @@
ImGuiID ImGui::GetWindowResizeCornerID(ImGuiWindow* window, int n)
{
IM_ASSERT(n >= 0 && n < 4);
- ImGuiID id = window->ID;
+ ImGuiID id = window->DockIsActive ? window->DockNode->HostWindow->ID : window->ID;
id = ImHashStr("#RESIZE", 0, id);
id = ImHashData(&n, sizeof(int), id);
return id;
@@ -6104,7 +6393,7 @@
{
IM_ASSERT(dir >= 0 && dir < 4);
int n = (int)dir + 4;
- ImGuiID id = window->ID;
+ ImGuiID id = window->DockIsActive ? window->DockNode->HostWindow->ID : window->ID;
id = ImHashStr("#RESIZE", 0, id);
id = ImHashData(&n, sizeof(int), id);
return id;
@@ -6135,6 +6424,16 @@
ImVec2 pos_target(FLT_MAX, FLT_MAX);
ImVec2 size_target(FLT_MAX, FLT_MAX);
+ // Clip mouse interaction rectangles within the viewport rectangle (in practice the narrowing is going to happen most of the time).
+ // - Not narrowing would mostly benefit the situation where OS windows _without_ decoration have a threshold for hovering when outside their limits.
+ // This is however not the case with current backends under Win32, but a custom borderless window implementation would benefit from it.
+ // - When decoration are enabled we typically benefit from that distance, but then our resize elements would be conflicting with OS resize elements, so we also narrow.
+ // - Note that we are unable to tell if the platform setup allows hovering with a distance threshold (on Win32, decorated window have such threshold).
+ // We only clip interaction so we overwrite window->ClipRect, cannot call PushClipRect() yet as DrawList is not yet setup.
+ const bool clip_with_viewport_rect = !(g.IO.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport) || (g.IO.MouseHoveredViewport != window->ViewportId) || !(window->Viewport->Flags & ImGuiViewportFlags_NoDecoration);
+ if (clip_with_viewport_rect)
+ window->ClipRect = window->Viewport->GetMainRect();
+
// Resize grips and borders are on layer 1
window->DC.NavLayerCurrent = ImGuiNavLayer_Menu;
@@ -6220,7 +6519,7 @@
// Switch to relative resizing mode when border geometry moved (e.g. resizing a child altering parent scroll), in order to avoid resizing feedback loop.
// Currently only using relative mode on resizable child windows, as the problem to solve is more likely noticeable for them, but could apply for all windows eventually.
// FIXME: May want to generalize this idiom at lower-level, so more widgets can use it!
- const bool just_scrolled_manually_while_resizing = (g.WheelingWindow != NULL && g.WheelingWindowScrolledFrame == g.FrameCount && IsWindowChildOf(window, g.WheelingWindow, false));
+ const bool just_scrolled_manually_while_resizing = (g.WheelingWindow != NULL && g.WheelingWindowScrolledFrame == g.FrameCount && IsWindowChildOf(window, g.WheelingWindow, false, true));
if (g.ActiveIdIsJustActivated || just_scrolled_manually_while_resizing)
{
g.WindowResizeBorderExpectedRect = border_rect;
@@ -6278,7 +6577,7 @@
// Navigation resize (keyboard/gamepad)
// FIXME: This cannot be moved to NavUpdateWindowing() because CalcWindowSizeAfterConstraint() need to callback into user.
// Not even sure the callback works here.
- if (g.NavWindowingTarget && g.NavWindowingTarget->RootWindow == window)
+ if (g.NavWindowingTarget && g.NavWindowingTarget->RootWindowDockTree == window)
{
ImVec2 nav_resize_dir;
if (g.NavInputSource == ImGuiInputSource_Keyboard && g.IO.KeyShift)
@@ -6329,7 +6628,9 @@
{
ImGuiContext& g = *GImGui;
ImVec2 size_for_clamping = window->Size;
- if (g.IO.ConfigWindowsMoveFromTitleBarOnly && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
+ if (g.IO.ConfigWindowsMoveFromTitleBarOnly && window->DockNodeAsHost)
+ size_for_clamping.y = ImGui::GetFrameHeight(); // Not using window->TitleBarHeight() as DockNodeAsHost will report 0.0f here.
+ else if (g.IO.ConfigWindowsMoveFromTitleBarOnly && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
size_for_clamping.y = window->TitleBarHeight;
window->Pos = ImClamp(window->Pos, visibility_rect.Min - size_for_clamping, visibility_rect.Max);
}
@@ -6364,7 +6665,7 @@
const ImU32 border_col_resizing = GetColorU32((window->ResizeBorderHeld != -1) ? ImGuiCol_SeparatorActive : ImGuiCol_SeparatorHovered);
RenderWindowOuterSingleBorder(window, border_n, border_col_resizing, ImMax(2.0f, window->WindowBorderSize)); // Thicker than usual
}
- if (g.Style.FrameBorderSize > 0 && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
+ if (g.Style.FrameBorderSize > 0 && !(window->Flags & ImGuiWindowFlags_NoTitleBar) && !window->DockIsActive)
{
float y = window->Pos.y + window->TitleBarHeight - 1;
window->DrawList->AddLine(ImVec2(window->Pos.x + border_size, y), ImVec2(window->Pos.x + window->Size.x - border_size, y), border_col, g.Style.FrameBorderSize);
@@ -6393,6 +6694,8 @@
const float backup_border_size = style.FrameBorderSize;
g.Style.FrameBorderSize = window->WindowBorderSize;
ImU32 title_bar_col = GetColorU32((title_bar_is_highlight && !g.NavDisableHighlight) ? ImGuiCol_TitleBgActive : ImGuiCol_TitleBgCollapsed);
+ if (window->ViewportOwned)
+ title_bar_col |= IM_COL32_A_MASK; // No alpha (we don't support is_docking_transparent_payload here because simpler and less meaningful, but could with a bit of code shuffle/reuse)
RenderFrame(title_bar_rect.Min, title_bar_rect.Max, title_bar_col, true, window_rounding);
g.Style.FrameBorderSize = backup_border_size;
}
@@ -6401,23 +6704,58 @@
// Window background
if (!(flags & ImGuiWindowFlags_NoBackground))
{
+ bool is_docking_transparent_payload = false;
+ if (g.DragDropActive && (g.FrameCount - g.DragDropAcceptFrameCount) <= 1 && g.IO.ConfigDockingTransparentPayload)
+ if (g.DragDropPayload.IsDataType(IMGUI_PAYLOAD_TYPE_WINDOW) && *(ImGuiWindow**)g.DragDropPayload.Data == window)
+ is_docking_transparent_payload = true;
+
ImU32 bg_col = GetColorU32(GetWindowBgColorIdx(window));
- bool override_alpha = false;
- float alpha = 1.0f;
- if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasBgAlpha)
+ if (window->ViewportOwned)
{
- alpha = g.NextWindowData.BgAlphaVal;
- override_alpha = true;
+ bg_col |= IM_COL32_A_MASK; // No alpha
+ if (is_docking_transparent_payload)
+ window->Viewport->Alpha *= DOCKING_TRANSPARENT_PAYLOAD_ALPHA;
}
- if (override_alpha)
- bg_col = (bg_col & ~IM_COL32_A_MASK) | (IM_F32_TO_INT8_SAT(alpha) << IM_COL32_A_SHIFT);
- window->DrawList->AddRectFilled(window->Pos + ImVec2(0, window->TitleBarHeight), window->Pos + window->Size, bg_col, window_rounding, (flags & ImGuiWindowFlags_NoTitleBar) ? 0 : ImDrawFlags_RoundCornersBottom);
+ else
+ {
+ // Adjust alpha. For docking
+ bool override_alpha = false;
+ float alpha = 1.0f;
+ if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasBgAlpha)
+ {
+ alpha = g.NextWindowData.BgAlphaVal;
+ override_alpha = true;
+ }
+ if (is_docking_transparent_payload)
+ {
+ alpha *= DOCKING_TRANSPARENT_PAYLOAD_ALPHA; // FIXME-DOCK: Should that be an override?
+ override_alpha = true;
+ }
+ if (override_alpha)
+ bg_col = (bg_col & ~IM_COL32_A_MASK) | (IM_F32_TO_INT8_SAT(alpha) << IM_COL32_A_SHIFT);
+ }
+
+ // Render, for docked windows and host windows we ensure bg goes before decorations
+ if (window->DockIsActive)
+ window->DockNode->LastBgColor = bg_col;
+ ImDrawList* bg_draw_list = window->DockIsActive ? window->DockNode->HostWindow->DrawList : window->DrawList;
+ if (window->DockIsActive || (flags & ImGuiWindowFlags_DockNodeHost))
+ bg_draw_list->ChannelsSetCurrent(DOCKING_HOST_DRAW_CHANNEL_BG);
+ bg_draw_list->AddRectFilled(window->Pos + ImVec2(0, window->TitleBarHeight), window->Pos + window->Size, bg_col, window_rounding, (flags & ImGuiWindowFlags_NoTitleBar) ? 0 : ImDrawFlags_RoundCornersBottom);
+ if (window->DockIsActive || (flags & ImGuiWindowFlags_DockNodeHost))
+ bg_draw_list->ChannelsSetCurrent(DOCKING_HOST_DRAW_CHANNEL_FG);
}
+ if (window->DockIsActive)
+ window->DockNode->IsBgDrawnThisFrame = true;
// Title bar
- if (!(flags & ImGuiWindowFlags_NoTitleBar))
+ // (when docked, DockNode are drawing their own title bar. Individual windows however do NOT set the _NoTitleBar flag,
+ // in order for their pos/size to be matching their undocking state.)
+ if (!(flags & ImGuiWindowFlags_NoTitleBar) && !window->DockIsActive)
{
ImU32 title_bar_col = GetColorU32(title_bar_is_highlight ? ImGuiCol_TitleBgActive : ImGuiCol_TitleBg);
+ if (window->ViewportOwned)
+ title_bar_col |= IM_COL32_A_MASK; // No alpha
window->DrawList->AddRectFilled(title_bar_rect.Min, title_bar_rect.Max, title_bar_col, window_rounding, ImDrawFlags_RoundCornersTop);
}
@@ -6431,6 +6769,27 @@
window->DrawList->AddLine(menu_bar_rect.GetBL(), menu_bar_rect.GetBR(), GetColorU32(ImGuiCol_Border), style.FrameBorderSize);
}
+ // Docking: Unhide tab bar (small triangle in the corner), drag from small triangle to quickly undock
+ ImGuiDockNode* node = window->DockNode;
+ if (window->DockIsActive && node->IsHiddenTabBar() && !node->IsNoTabBar())
+ {
+ float unhide_sz_draw = ImTrunc(g.FontSize * 0.70f);
+ float unhide_sz_hit = ImTrunc(g.FontSize * 0.55f);
+ ImVec2 p = node->Pos;
+ ImRect r(p, p + ImVec2(unhide_sz_hit, unhide_sz_hit));
+ ImGuiID unhide_id = window->GetID("#UNHIDE");
+ KeepAliveID(unhide_id);
+ bool hovered, held;
+ if (ButtonBehavior(r, unhide_id, &hovered, &held, ImGuiButtonFlags_FlattenChildren))
+ node->WantHiddenTabBarToggle = true;
+ else if (held && IsMouseDragging(0))
+ StartMouseMovingWindowOrNode(window, node, true); // Undock from tab-bar triangle = same as window/collapse menu button
+
+ // FIXME-DOCK: Ideally we'd use ImGuiCol_TitleBgActive/ImGuiCol_TitleBg here, but neither is guaranteed to be visible enough at this sort of size..
+ ImU32 col = GetColorU32(((held && hovered) || (node->IsFocused && !hovered)) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
+ window->DrawList->AddTriangleFilled(p, p + ImVec2(unhide_sz_draw, 0.0f), p + ImVec2(0.0f, unhide_sz_draw), col);
+ }
+
// Scrollbars
if (window->ScrollbarX)
Scrollbar(ImGuiAxis_X);
@@ -6454,12 +6813,13 @@
}
}
- // Borders
- if (handle_borders_and_resize_grips)
+ // Borders (for dock node host they will be rendered over after the tab bar)
+ if (handle_borders_and_resize_grips && !window->DockNodeAsHost)
RenderWindowOuterBorders(window);
}
}
+// When inside a dock node, this is handled in DockNodeCalcTabBarLayout() instead.
// Render title text, collapse button, close button
void ImGui::RenderWindowTitleBarContents(ImGuiWindow* window, const ImRect& title_bar_rect, const char* name, bool* p_open)
{
@@ -6501,7 +6861,7 @@
// Collapse button (submitting first so it gets priority when choosing a navigation init fallback)
if (has_collapse_button)
- if (CollapseButton(window->GetID("#COLLAPSE"), collapse_button_pos))
+ if (CollapseButton(window->GetID("#COLLAPSE"), collapse_button_pos, NULL))
window->WantCollapseToggle = true; // Defer actual collapsing to next frame as we are too far in the Begin() function
// Close button
@@ -6552,12 +6912,16 @@
void ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window)
{
window->ParentWindow = parent_window;
- window->RootWindow = window->RootWindowPopupTree = window->RootWindowForTitleBarHighlight = window->RootWindowForNav = window;
+ window->RootWindow = window->RootWindowPopupTree = window->RootWindowDockTree = window->RootWindowForTitleBarHighlight = window->RootWindowForNav = window;
if (parent_window && (flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Tooltip))
- window->RootWindow = parent_window->RootWindow;
+ {
+ window->RootWindowDockTree = parent_window->RootWindowDockTree;
+ if (!window->DockIsActive && !(parent_window->Flags & ImGuiWindowFlags_DockNodeHost))
+ window->RootWindow = parent_window->RootWindow;
+ }
if (parent_window && (flags & ImGuiWindowFlags_Popup))
window->RootWindowPopupTree = parent_window->RootWindowPopupTree;
- if (parent_window && !(flags & ImGuiWindowFlags_Modal) && (flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)))
+ if (parent_window && !(flags & ImGuiWindowFlags_Modal) && (flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup))) // FIXME: simply use _NoTitleBar ?
window->RootWindowForTitleBarHighlight = parent_window->RootWindowForTitleBarHighlight;
while (window->RootWindowForNav->ChildFlags & ImGuiChildFlags_NavFlattened)
{
@@ -6672,22 +7036,24 @@
const bool first_begin_of_the_frame = (window->LastFrameActive != current_frame);
window->IsFallbackWindow = (g.CurrentWindowStack.Size == 0 && g.WithinFrameScopeWithImplicitWindow);
- // Update the Appearing flag
- bool window_just_activated_by_user = (window->LastFrameActive < current_frame - 1); // Not using !WasActive because the implicit "Debug" window would always toggle off->on
+ // Update the Appearing flag (note: the BeginDocked() path may also set this to true later)
+ bool window_just_activated_by_user = (window->LastFrameActive < current_frame - 1); // Not using !WasActive because the implicit "Debug" window would always toggle off->on
if (flags & ImGuiWindowFlags_Popup)
{
ImGuiPopupData& popup_ref = g.OpenPopupStack[g.BeginPopupStack.Size];
window_just_activated_by_user |= (window->PopupId != popup_ref.PopupId); // We recycle popups so treat window as activated if popup id changed
window_just_activated_by_user |= (window != popup_ref.Window);
}
- window->Appearing = window_just_activated_by_user;
- if (window->Appearing)
- SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, true);
// Update Flags, LastFrameActive, BeginOrderXXX fields
+ const bool window_was_appearing = window->Appearing;
if (first_begin_of_the_frame)
{
UpdateWindowInFocusOrderList(window, window_just_created, flags);
+ window->Appearing = window_just_activated_by_user;
+ if (window->Appearing)
+ SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, true);
+ window->FlagsPreviousFrame = window->Flags;
window->Flags = (ImGuiWindowFlags)flags;
window->ChildFlags = (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasChildFlags) ? g.NextWindowData.ChildFlags : 0;
window->LastFrameActive = current_frame;
@@ -6700,8 +7066,42 @@
flags = window->Flags;
}
+ // Docking
+ // (NB: during the frame dock nodes are created, it is possible that (window->DockIsActive == false) even though (window->DockNode->Windows.Size > 1)
+ IM_ASSERT(window->DockNode == NULL || window->DockNodeAsHost == NULL); // Cannot be both
+ if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasDock)
+ SetWindowDock(window, g.NextWindowData.DockId, g.NextWindowData.DockCond);
+ if (first_begin_of_the_frame)
+ {
+ bool has_dock_node = (window->DockId != 0 || window->DockNode != NULL);
+ bool new_auto_dock_node = !has_dock_node && GetWindowAlwaysWantOwnTabBar(window);
+ bool dock_node_was_visible = window->DockNodeIsVisible;
+ bool dock_tab_was_visible = window->DockTabIsVisible;
+ if (has_dock_node || new_auto_dock_node)
+ {
+ BeginDocked(window, p_open);
+ flags = window->Flags;
+ if (window->DockIsActive)
+ {
+ IM_ASSERT(window->DockNode != NULL);
+ g.NextWindowData.Flags &= ~ImGuiNextWindowDataFlags_HasSizeConstraint; // Docking currently override constraints
+ }
+
+ // Amend the Appearing flag
+ if (window->DockTabIsVisible && !dock_tab_was_visible && dock_node_was_visible && !window->Appearing && !window_was_appearing)
+ {
+ window->Appearing = true;
+ SetWindowConditionAllowFlags(window, ImGuiCond_Appearing, true);
+ }
+ }
+ else
+ {
+ window->DockIsActive = window->DockNodeIsVisible = window->DockTabIsVisible = false;
+ }
+ }
+
// Parent window is latched only on the first call to Begin() of the frame, so further append-calls can be done from a different window stack
- ImGuiWindow* parent_window_in_stack = g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back().Window;
+ ImGuiWindow* parent_window_in_stack = (window->DockIsActive && window->DockNode->HostWindow) ? window->DockNode->HostWindow : g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back().Window;
ImGuiWindow* parent_window = first_begin_of_the_frame ? ((flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)) ? parent_window_in_stack : NULL) : window->ParentWindow;
IM_ASSERT(parent_window != NULL || !(flags & ImGuiWindowFlags_ChildWindow));
@@ -6726,9 +7126,20 @@
UpdateWindowParentAndRootLinks(window, flags, parent_window);
window->ParentWindowInBeginStack = parent_window_in_stack;
+ // Focus route
// There's little point to expose a flag to set this: because the interesting cases won't be using parent_window_in_stack,
- // e.g. linking a tool window in a standalone viewport to a document window, regardless of their Begin() stack parenting. (#6798)
- window->ParentWindowForFocusRoute = (flags & ImGuiWindowFlags_ChildWindow) ? parent_window_in_stack : NULL;
+ // Use for e.g. linking a tool window in a standalone viewport to a document window, regardless of their Begin() stack parenting. (#6798)
+ window->ParentWindowForFocusRoute = (window->RootWindow != window) ? parent_window_in_stack : NULL;
+ if (window->ParentWindowForFocusRoute == NULL && window->DockNode != NULL)
+ if (window->DockNode->MergedFlags & ImGuiDockNodeFlags_DockedWindowsInFocusRoute)
+ window->ParentWindowForFocusRoute = window->DockNode->HostWindow;
+
+ // Override with SetNextWindowClass() field or direct call to SetWindowParentWindowForFocusRoute()
+ if (window->WindowClass.FocusRouteParentWindowId != 0)
+ {
+ window->ParentWindowForFocusRoute = FindWindowByID(window->WindowClass.FocusRouteParentWindowId);
+ IM_ASSERT(window->ParentWindowForFocusRoute != 0); // Invalid value for FocusRouteParentWindowId.
+ }
}
// Add to focus scope stack
@@ -6792,6 +7203,8 @@
window->ContentSizeExplicit = g.NextWindowData.ContentSizeVal;
else if (first_begin_of_the_frame)
window->ContentSizeExplicit = ImVec2(0.0f, 0.0f);
+ if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasWindowClass)
+ window->WindowClass = g.NextWindowData.WindowClass;
if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasCollapsed)
SetWindowCollapsed(window, g.NextWindowData.CollapsedVal, g.NextWindowData.CollapsedCond);
if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasFocus)
@@ -6821,6 +7234,11 @@
window->IDStack.resize(1);
window->DrawList->_ResetForNewFrame();
window->DC.CurrentTableIdx = -1;
+ if (flags & ImGuiWindowFlags_DockNodeHost)
+ {
+ window->DrawList->ChannelsSplit(2);
+ window->DrawList->ChannelsSetCurrent(DOCKING_HOST_DRAW_CHANNEL_FG); // Render decorations on channel 1 as we will render the backgrounds manually later
+ }
// Restore buffer capacity when woken from a compacted state, to avoid
if (window->MemoryCompacted)
@@ -6829,7 +7247,9 @@
// Update stored window name when it changes (which can _only_ happen with the "###" operator, so the ID would stay unchanged).
// The title bar always display the 'name' parameter, so we only update the string storage if it needs to be visible to the end-user elsewhere.
bool window_title_visible_elsewhere = false;
- if (g.NavWindowingListWindow != NULL && (window->Flags & ImGuiWindowFlags_NoNavFocus) == 0) // Window titles visible when using CTRL+TAB
+ if ((window->Viewport && window->Viewport->Window == window) || (window->DockIsActive))
+ window_title_visible_elsewhere = true;
+ else if (g.NavWindowingListWindow != NULL && (window->Flags & ImGuiWindowFlags_NoNavFocus) == 0) // Window titles visible when using CTRL+TAB
window_title_visible_elsewhere = true;
if (window_title_visible_elsewhere && !window_just_created && strcmp(name, window->Name) != 0)
{
@@ -6842,6 +7262,10 @@
// Update contents size from last frame for auto-fitting (or use explicit size)
CalcWindowContentSizes(window, &window->ContentSize, &window->ContentSizeIdeal);
+
+ // FIXME: These flags are decremented before they are used. This means that in order to have these fields produce their intended behaviors
+ // for one frame we must set them to at least 2, which is counter-intuitive. HiddenFramesCannotSkipItems is a more complicated case because
+ // it has a single usage before this code block and may be set below before it is finally checked.
if (window->HiddenFramesCanSkipItems > 0)
window->HiddenFramesCanSkipItems--;
if (window->HiddenFramesCannotSkipItems > 0)
@@ -6869,20 +7293,23 @@
}
// SELECT VIEWPORT
- // FIXME-VIEWPORT: In the docking/viewport branch, this is the point where we select the current viewport (which may affect the style)
+ // We need to do this before using any style/font sizes, as viewport with a different DPI may affect font sizes.
- ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)GetMainViewport();
- SetWindowViewport(window, viewport);
+ WindowSelectViewport(window);
+ SetCurrentViewport(window, window->Viewport);
+ window->FontDpiScale = (g.IO.ConfigFlags & ImGuiConfigFlags_DpiEnableScaleFonts) ? window->Viewport->DpiScale : 1.0f;
SetCurrentWindow(window);
+ flags = window->Flags;
// LOCK BORDER SIZE AND PADDING FOR THE FRAME (so that altering them doesn't cause inconsistencies)
+ // We read Style data after the call to UpdateSelectWindowViewport() which might be swapping the style.
- if (flags & ImGuiWindowFlags_ChildWindow)
+ if (!window->DockIsActive && (flags & ImGuiWindowFlags_ChildWindow))
window->WindowBorderSize = style.ChildBorderSize;
else
window->WindowBorderSize = ((flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)) && !(flags & ImGuiWindowFlags_Modal)) ? style.PopupBorderSize : style.WindowBorderSize;
window->WindowPadding = style.WindowPadding;
- if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup) && !(window->ChildFlags & ImGuiChildFlags_AlwaysUseWindowPadding) && window->WindowBorderSize == 0.0f)
+ if (!window->DockIsActive && (flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup) && !(window->ChildFlags & ImGuiChildFlags_AlwaysUseWindowPadding) && window->WindowBorderSize == 0.0f)
window->WindowPadding = ImVec2(0.0f, (flags & ImGuiWindowFlags_MenuBar) ? style.WindowPadding.y : 0.0f);
// Lock menu offset so size calculation can use it as menu-bar windows need a minimum size.
@@ -6902,7 +7329,7 @@
// Collapse window by double-clicking on title bar
// At this point we don't have a clipping rectangle setup yet, so we can use the title bar area for hit detection and drawing
- if (!(flags & ImGuiWindowFlags_NoTitleBar) && !(flags & ImGuiWindowFlags_NoCollapse))
+ if (!(flags & ImGuiWindowFlags_NoTitleBar) && !(flags & ImGuiWindowFlags_NoCollapse) && !window->DockIsActive)
{
// We don't use a regular button+id to test for double-click on title bar (mostly due to legacy reason, could be fixed), so verify that we don't have items over the title bar.
ImRect title_bar_rect = window->TitleBarRect();
@@ -7002,23 +7429,66 @@
else if ((flags & ImGuiWindowFlags_Tooltip) != 0 && !window_pos_set_by_api && !window_is_child_tooltip)
window->Pos = FindBestWindowPosForPopup(window);
+ // Late create viewport if we don't fit within our current host viewport.
+ if (window->ViewportAllowPlatformMonitorExtend >= 0 && !window->ViewportOwned && !(window->Viewport->Flags & ImGuiViewportFlags_IsMinimized))
+ if (!window->Viewport->GetMainRect().Contains(window->Rect()))
+ {
+ // This is based on the assumption that the DPI will be known ahead (same as the DPI of the selection done in UpdateSelectWindowViewport)
+ //ImGuiViewport* old_viewport = window->Viewport;
+ window->Viewport = AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_NoFocusOnAppearing);
+
+ // FIXME-DPI
+ //IM_ASSERT(old_viewport->DpiScale == window->Viewport->DpiScale); // FIXME-DPI: Something went wrong
+ SetCurrentViewport(window, window->Viewport);
+ window->FontDpiScale = (g.IO.ConfigFlags & ImGuiConfigFlags_DpiEnableScaleFonts) ? window->Viewport->DpiScale : 1.0f;
+ SetCurrentWindow(window);
+ }
+
+ if (window->ViewportOwned)
+ WindowSyncOwnedViewport(window, parent_window_in_stack);
+
// Calculate the range of allowed position for that window (to be movable and visible past safe area padding)
// When clamping to stay visible, we will enforce that window->Pos stays inside of visibility_rect.
- ImRect viewport_rect(viewport->GetMainRect());
- ImRect viewport_work_rect(viewport->GetWorkRect());
+ ImRect viewport_rect(window->Viewport->GetMainRect());
+ ImRect viewport_work_rect(window->Viewport->GetWorkRect());
ImVec2 visibility_padding = ImMax(style.DisplayWindowPadding, style.DisplaySafeAreaPadding);
ImRect visibility_rect(viewport_work_rect.Min + visibility_padding, viewport_work_rect.Max - visibility_padding);
// Clamp position/size so window stays visible within its viewport or monitor
// Ignore zero-sized display explicitly to avoid losing positions if a window manager reports zero-sized window when initializing or minimizing.
+ // FIXME: Similar to code in GetWindowAllowedExtentRect()
if (!window_pos_set_by_api && !(flags & ImGuiWindowFlags_ChildWindow))
- if (viewport_rect.GetWidth() > 0.0f && viewport_rect.GetHeight() > 0.0f)
+ {
+ if (!window->ViewportOwned && viewport_rect.GetWidth() > 0 && viewport_rect.GetHeight() > 0.0f)
+ {
ClampWindowPos(window, visibility_rect);
+ }
+ else if (window->ViewportOwned && g.PlatformIO.Monitors.Size > 0)
+ {
+ if (g.MovingWindow != NULL && window->RootWindowDockTree == g.MovingWindow->RootWindowDockTree)
+ {
+ // While moving windows we allow them to straddle monitors (#7299, #3071)
+ visibility_rect = g.PlatformMonitorsFullWorkRect;
+ }
+ else
+ {
+ // When not moving ensure visible in its monitor
+ // Lost windows (e.g. a monitor disconnected) will naturally moved to the fallback/dummy monitor aka the main viewport.
+ const ImGuiPlatformMonitor* monitor = GetViewportPlatformMonitor(window->Viewport);
+ visibility_rect = ImRect(monitor->WorkPos, monitor->WorkPos + monitor->WorkSize);
+ }
+ visibility_rect.Expand(-visibility_padding);
+ ClampWindowPos(window, visibility_rect);
+ }
+ }
window->Pos = ImTrunc(window->Pos);
// Lock window rounding for the frame (so that altering them doesn't cause inconsistencies)
// Large values tend to lead to variety of artifacts and are not recommended.
- window->WindowRounding = (flags & ImGuiWindowFlags_ChildWindow) ? style.ChildRounding : ((flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiWindowFlags_Modal)) ? style.PopupRounding : style.WindowRounding;
+ if (window->ViewportOwned || window->DockIsActive)
+ window->WindowRounding = 0.0f;
+ else
+ window->WindowRounding = (flags & ImGuiWindowFlags_ChildWindow) ? style.ChildRounding : ((flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiWindowFlags_Modal)) ? style.PopupRounding : style.WindowRounding;
// For windows with title bar or menu bar, we clamp to FrameHeight(FontSize + FramePadding.y * 2.0f) to completely hide artifacts.
//if ((window->Flags & ImGuiWindowFlags_MenuBar) || !(window->Flags & ImGuiWindowFlags_NoTitleBar))
@@ -7030,7 +7500,7 @@
{
if (flags & ImGuiWindowFlags_Popup)
want_focus = true;
- else if ((flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Tooltip)) == 0)
+ else if ((window->DockIsActive || (flags & ImGuiWindowFlags_ChildWindow) == 0) && !(flags & ImGuiWindowFlags_Tooltip))
want_focus = true;
}
@@ -7046,12 +7516,15 @@
}
#endif
+ // Decide if we are going to handle borders and resize grips
+ const bool handle_borders_and_resize_grips = (window->DockNodeAsHost || !window->DockIsActive);
+
// Handle manual resize: Resize Grips, Borders, Gamepad
int border_hovered = -1, border_held = -1;
ImU32 resize_grip_col[4] = {};
const int resize_grip_count = ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup)) ? 0 : g.IO.ConfigWindowsResizeFromEdges ? 2 : 1; // Allow resize from lower-left if we have the mouse cursor feedback for it.
const float resize_grip_draw_size = IM_TRUNC(ImMax(g.FontSize * 1.10f, window->WindowRounding + 1.0f + g.FontSize * 0.2f));
- if (!window->Collapsed)
+ if (handle_borders_and_resize_grips && !window->Collapsed)
if (int auto_fit_mask = UpdateWindowManualResize(window, size_auto_fit, &border_hovered, &border_held, resize_grip_count, &resize_grip_col[0], visibility_rect))
{
if (auto_fit_mask & (1 << ImGuiAxis_X))
@@ -7062,6 +7535,20 @@
window->ResizeBorderHovered = (signed char)border_hovered;
window->ResizeBorderHeld = (signed char)border_held;
+ // Synchronize window --> viewport again and one last time (clamping and manual resize may have affected either)
+ if (window->ViewportOwned)
+ {
+ if (!window->Viewport->PlatformRequestMove)
+ window->Viewport->Pos = window->Pos;
+ if (!window->Viewport->PlatformRequestResize)
+ window->Viewport->Size = window->Size;
+ window->Viewport->UpdateWorkRect();
+ viewport_rect = window->Viewport->GetMainRect();
+ }
+
+ // Save last known viewport position within the window itself (so it can be saved in .ini file and restored)
+ window->ViewportPos = window->Viewport->Pos;
+
// SCROLLBAR VISIBILITY
// Update scrollbar visibility (based on the Size that was effective during last frame or the auto-resized Size).
@@ -7100,6 +7587,8 @@
const ImRect outer_rect = window->Rect();
const ImRect title_bar_rect = window->TitleBarRect();
window->OuterRectClipped = outer_rect;
+ if (window->DockIsActive)
+ window->OuterRectClipped.Min.y += window->TitleBarHeight;
window->OuterRectClipped.ClipWith(host_rect);
// Inner rectangle
@@ -7162,6 +7651,8 @@
// Child windows can render their decoration (bg color, border, scrollbars, etc.) within their parent to save a draw call (since 1.71)
// When using overlapping child windows, this will break the assumption that child z-order is mapped to submission order.
// FIXME: User code may rely on explicit sorting of overlapping child window and would need to disable this somehow. Please get in contact if you are affected (github #4493)
+ const bool is_undocked_or_docked_visible = !window->DockIsActive || window->DockTabIsVisible;
+ if (is_undocked_or_docked_visible)
{
bool render_decorations_in_parent = false;
if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Popup) && !window_is_child_tooltip)
@@ -7179,8 +7670,7 @@
// Handle title bar, scrollbar, resize grips and resize borders
const ImGuiWindow* window_to_highlight = g.NavWindowingTarget ? g.NavWindowingTarget : g.NavWindow;
- const bool title_bar_is_highlight = want_focus || (window_to_highlight && window->RootWindowForTitleBarHighlight == window_to_highlight->RootWindowForTitleBarHighlight);
- const bool handle_borders_and_resize_grips = true; // This exists to facilitate merge with 'docking' branch.
+ const bool title_bar_is_highlight = want_focus || (window_to_highlight && (window->RootWindowForTitleBarHighlight == window_to_highlight->RootWindowForTitleBarHighlight || (window->DockNode && window->DockNode == window_to_highlight->DockNode)));
RenderWindowDecorations(window, title_bar_rect, title_bar_is_highlight, handle_borders_and_resize_grips, resize_grip_count, resize_grip_col, resize_grip_draw_size);
if (render_decorations_in_parent)
@@ -7263,6 +7753,9 @@
if (window->AutoFitFramesY > 0)
window->AutoFitFramesY--;
+ // Clear SetNextWindowXXX data (can aim to move this higher in the function)
+ g.NextWindowData.ClearFlags();
+
// Apply focus (we need to call FocusWindow() AFTER setting DC.CursorStartPos so our initial navigation reference rectangle can start around there)
// We ImGuiFocusRequestFlags_UnlessBelowModal to:
// - Avoid focusing a window that is created outside of a modal. This will prevent active modal from being closed.
@@ -7272,8 +7765,16 @@
if (want_focus && window == g.NavWindow)
NavInitWindow(window, false); // <-- this is in the way for us to be able to defer and sort reappearing FocusWindow() calls
+ // Close requested by platform window (apply to all windows in this viewport)
+ if (p_open != NULL && window->Viewport->PlatformRequestClose && window->Viewport != GetMainViewport())
+ {
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Window '%s' closed by PlatformRequestClose\n", window->Name);
+ *p_open = false;
+ g.NavWindowingToggleLayer = false; // Assume user mapped PlatformRequestClose on ALT-F4 so we disable ALT for menu toggle. False positive not an issue. // FIXME-NAV: Try removing.
+ }
+
// Title bar
- if (!(flags & ImGuiWindowFlags_NoTitleBar))
+ if (!(flags & ImGuiWindowFlags_NoTitleBar) && !window->DockIsActive)
RenderWindowTitleBarContents(window, ImRect(title_bar_rect.Min.x + window->WindowBorderSize, title_bar_rect.Min.y, title_bar_rect.Max.x - window->WindowBorderSize, title_bar_rect.Max.y), name, p_open);
// Clear hit test shape every frame
@@ -7289,6 +7790,20 @@
LogToClipboard();
*/
+ if (g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable)
+ {
+ // Docking: Dragging a dockable window (or any of its child) turns it into a drag and drop source.
+ // We need to do this _before_ we overwrite window->DC.LastItemId below because BeginDockableDragDropSource() also overwrites it.
+ if (g.MovingWindow == window && (window->RootWindowDockTree->Flags & ImGuiWindowFlags_NoDocking) == 0)
+ BeginDockableDragDropSource(window);
+
+ // Docking: Any dockable window can act as a target. For dock node hosts we call BeginDockableDragDropTarget() in DockNodeUpdate() instead.
+ if (g.DragDropActive && !(flags & ImGuiWindowFlags_NoDocking))
+ if (g.MovingWindow == NULL || g.MovingWindow->RootWindowDockTree != window)
+ if ((window == window->RootWindowDockTree) && !(window->Flags & ImGuiWindowFlags_DockNodeHost))
+ BeginDockableDragDropTarget(window);
+ }
+
// We fill last item data based on Title Bar/Tab, in order for IsItemHovered() and IsItemActive() to be usable after Begin().
// This is useful to allow creating context menus on title bar only, etc.
SetLastItemDataForWindow(window, title_bar_rect);
@@ -7312,26 +7827,39 @@
SetWindowActiveForSkipRefresh(window);
// Append
+ SetCurrentViewport(window, window->Viewport);
SetCurrentWindow(window);
+ g.NextWindowData.ClearFlags();
SetLastItemDataForWindow(window, window->TitleBarRect());
}
- if (!window->SkipRefresh)
+ if (!(flags & ImGuiWindowFlags_DockNodeHost) && !window->SkipRefresh)
PushClipRect(window->InnerClipRect.Min, window->InnerClipRect.Max, true);
// Clear 'accessed' flag last thing (After PushClipRect which will set the flag. We want the flag to stay false when the default "Debug" window is unused)
window->WriteAccessed = false;
window->BeginCount++;
- g.NextWindowData.ClearFlags();
// Update visibility
if (first_begin_of_the_frame && !window->SkipRefresh)
{
+ // When we are about to select this tab (which will only be visible on the _next frame_), flag it with a non-zero HiddenFramesCannotSkipItems.
+ // This will have the important effect of actually returning true in Begin() and not setting SkipItems, allowing an earlier submission of the window contents.
+ // This is analogous to regular windows being hidden from one frame.
+ // It is especially important as e.g. nested TabBars would otherwise generate flicker in the form of one empty frame, or focus requests won't be processed.
+ if (window->DockIsActive && !window->DockTabIsVisible)
+ {
+ if (window->LastFrameJustFocused == g.FrameCount)
+ window->HiddenFramesCannotSkipItems = 1;
+ else
+ window->HiddenFramesCanSkipItems = 1;
+ }
+
if ((flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_ChildMenu))
{
// Child window can be out of sight and have "negative" clip windows.
// Mark them as collapsed so commands are skipped earlier (we can't manually collapse them because they have no title bar).
- IM_ASSERT((flags & ImGuiWindowFlags_NoTitleBar) != 0);
+ IM_ASSERT((flags & ImGuiWindowFlags_NoTitleBar) != 0 || window->DockIsActive);
const bool nav_request = (window->ChildFlags & ImGuiChildFlags_NavFlattened) && (g.NavAnyRequest && g.NavWindow && g.NavWindow->RootWindowForNav == window->RootWindowForNav);
if (!g.LogEnabled && !nav_request)
if (window->OuterRectClipped.Min.x >= window->OuterRectClipped.Max.x || window->OuterRectClipped.Min.y >= window->OuterRectClipped.Max.y)
@@ -7370,6 +7898,16 @@
if (window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0 && window->HiddenFramesCannotSkipItems <= 0)
skip_items = true;
window->SkipItems = skip_items;
+
+ // Restore NavLayersActiveMaskNext to previous value when not visible, so a CTRL+Tab back can use a safe value.
+ if (window->SkipItems)
+ window->DC.NavLayersActiveMaskNext = window->DC.NavLayersActiveMask;
+
+ // Sanity check: there are two spots which can set Appearing = true
+ // - when 'window_just_activated_by_user' is set -> HiddenFramesCannotSkipItems is set -> SkipItems always false
+ // - in BeginDocked() path when DockNodeIsVisible == DockTabIsVisible == true -> hidden _should_ be all zero // FIXME: Not formally proven, hence the assert.
+ if (window->SkipItems && !window->Appearing)
+ IM_ASSERT(window->Appearing == false); // Please report on GitHub if this triggers: https://github.com/ocornut/imgui/issues/4177
}
else if (first_begin_of_the_frame)
{
@@ -7395,7 +7933,10 @@
static void ImGui::SetLastItemDataForWindow(ImGuiWindow* window, const ImRect& rect)
{
ImGuiContext& g = *GImGui;
- SetLastItemData(window->MoveId, g.CurrentItemFlags, IsMouseHoveringRect(rect.Min, rect.Max, false) ? ImGuiItemStatusFlags_HoveredRect : 0, rect);
+ if (window->DockIsActive)
+ SetLastItemData(window->MoveId, g.CurrentItemFlags, window->DockTabItemStatusFlags, window->DockTabItemRect);
+ else
+ SetLastItemData(window->MoveId, g.CurrentItemFlags, IsMouseHoveringRect(rect.Min, rect.Max, false) ? ImGuiItemStatusFlags_HoveredRect : 0, rect);
}
void ImGui::End()
@@ -7412,14 +7953,14 @@
ImGuiWindowStackData& window_stack_data = g.CurrentWindowStack.back();
// Error checking: verify that user doesn't directly call End() on a child window.
- if (window->Flags & ImGuiWindowFlags_ChildWindow)
+ if ((window->Flags & ImGuiWindowFlags_ChildWindow) && !(window->Flags & ImGuiWindowFlags_DockNodeHost) && !window->DockIsActive)
IM_ASSERT_USER_ERROR(g.WithinEndChild, "Must call EndChild() and not End()!");
// Close anything that is open
if (window->DC.CurrentColumns)
EndColumns();
- if (!window->SkipRefresh)
- PopClipRect(); // Inner window clip rectangle
+ if (!(window->Flags & ImGuiWindowFlags_DockNodeHost) && !window->SkipRefresh) // Pop inner window clip rectangle
+ PopClipRect();
PopFocusScope();
if (window_stack_data.DisabledOverrideReenable && window->RootWindow == window)
EndDisabledOverrideReenable();
@@ -7437,6 +7978,11 @@
if (window->DC.IsSetPos)
ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
+ // Docking: report contents sizes to parent to allow for auto-resize
+ if (window->DockNode && window->DockTabIsVisible)
+ if (ImGuiWindow* host_window = window->DockNode->HostWindow) // FIXME-DOCK
+ host_window->DC.CursorMaxPos = window->DC.CursorMaxPos + window->WindowPadding - host_window->WindowPadding;
+
// Pop from window stack
g.LastItemData = window_stack_data.ParentLastItemDataBackup;
if (window->Flags & ImGuiWindowFlags_ChildMenu)
@@ -7446,6 +7992,8 @@
window_stack_data.StackSizesOnBegin.CompareWithContextState(&g);
g.CurrentWindowStack.pop_back();
SetCurrentWindow(g.CurrentWindowStack.Size == 0 ? NULL : g.CurrentWindowStack.back().Window);
+ if (g.CurrentWindow)
+ SetCurrentViewport(g.CurrentWindow, g.CurrentWindow->Viewport);
}
void ImGui::BringWindowToFocusFront(ImGuiWindow* window)
@@ -7473,7 +8021,7 @@
{
ImGuiContext& g = *GImGui;
ImGuiWindow* current_front_window = g.Windows.back();
- if (current_front_window == window || current_front_window->RootWindow == window) // Cheap early out (could be better)
+ if (current_front_window == window || current_front_window->RootWindowDockTree == window) // Cheap early out (could be better)
return;
for (int i = g.Windows.Size - 2; i >= 0; i--) // We can ignore the top-most window
if (g.Windows[i] == window)
@@ -7566,31 +8114,39 @@
}
// Move the root window to the top of the pile
- IM_ASSERT(window == NULL || window->RootWindow != NULL);
- ImGuiWindow* focus_front_window = window ? window->RootWindow : NULL; // NB: In docking branch this is window->RootWindowDockStop
- ImGuiWindow* display_front_window = window ? window->RootWindow : NULL;
+ IM_ASSERT(window == NULL || window->RootWindowDockTree != NULL);
+ ImGuiWindow* focus_front_window = window ? window->RootWindow : NULL;
+ ImGuiWindow* display_front_window = window ? window->RootWindowDockTree : NULL;
+ ImGuiDockNode* dock_node = window ? window->DockNode : NULL;
+ bool active_id_window_is_dock_node_host = (g.ActiveIdWindow && dock_node && dock_node->HostWindow == g.ActiveIdWindow);
// Steal active widgets. Some of the cases it triggers includes:
// - Focus a window while an InputText in another window is active, if focus happens before the old InputText can run.
// - When using Nav to activate menu items (due to timing of activating on press->new window appears->losing ActiveId)
+ // - Using dock host items (tab, collapse button) can trigger this before we redirect the ActiveIdWindow toward the child window.
if (g.ActiveId != 0 && g.ActiveIdWindow && g.ActiveIdWindow->RootWindow != focus_front_window)
- if (!g.ActiveIdNoClearOnFocusLoss)
+ if (!g.ActiveIdNoClearOnFocusLoss && !active_id_window_is_dock_node_host)
ClearActiveID();
// Passing NULL allow to disable keyboard focus
if (!window)
return;
+ window->LastFrameJustFocused = g.FrameCount;
+
+ // Select in dock node
+ // For #2304 we avoid applying focus immediately before the tabbar is visible.
+ //if (dock_node && dock_node->TabBar)
+ // dock_node->TabBar->SelectedTabId = dock_node->TabBar->NextSelectedTabId = window->TabId;
// Bring to front
BringWindowToFocusFront(focus_front_window);
- if (((window->Flags | display_front_window->Flags) & ImGuiWindowFlags_NoBringToFrontOnFocus) == 0)
+ if (((window->Flags | focus_front_window->Flags | display_front_window->Flags) & ImGuiWindowFlags_NoBringToFrontOnFocus) == 0)
BringWindowToDisplayFront(display_front_window);
}
void ImGui::FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window, ImGuiViewport* filter_viewport, ImGuiFocusRequestFlags flags)
{
ImGuiContext& g = *GImGui;
- IM_UNUSED(filter_viewport); // Unused in master branch.
int start_idx = g.WindowsFocusOrder.Size - 1;
if (under_this_window != NULL)
{
@@ -7609,8 +8165,15 @@
ImGuiWindow* window = g.WindowsFocusOrder[i];
if (window == ignore_window || !window->WasActive)
continue;
+ if (filter_viewport != NULL && window->Viewport != filter_viewport)
+ continue;
if ((window->Flags & (ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs)) != (ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs))
{
+ // FIXME-DOCK: When ImGuiFocusRequestFlags_RestoreFocusedChild is set...
+ // This is failing (lagging by one frame) for docked windows.
+ // If A and B are docked into window and B disappear, at the NewFrame() call site window->NavLastChildNavWindow will still point to B.
+ // We might leverage the tab order implicitly stored in window->DockNodeAsHost->TabBar (essentially the 'most_recently_selected_tab' code in tab bar will do that but on next update)
+ // to tell which is the "previous" window. Or we may leverage 'LastFrameFocused/LastFrameJustFocused' and have this function handle child window itself?
FocusWindow(window, flags);
return;
}
@@ -7756,7 +8319,7 @@
window->DC.TextWrapPosStack.pop_back();
}
-static ImGuiWindow* GetCombinedRootWindow(ImGuiWindow* window, bool popup_hierarchy)
+static ImGuiWindow* GetCombinedRootWindow(ImGuiWindow* window, bool popup_hierarchy, bool dock_hierarchy)
{
ImGuiWindow* last_window = NULL;
while (last_window != window)
@@ -7765,13 +8328,15 @@
window = window->RootWindow;
if (popup_hierarchy)
window = window->RootWindowPopupTree;
- }
+ if (dock_hierarchy)
+ window = window->RootWindowDockTree;
+ }
return window;
}
-bool ImGui::IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent, bool popup_hierarchy)
+bool ImGui::IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent, bool popup_hierarchy, bool dock_hierarchy)
{
- ImGuiWindow* window_root = GetCombinedRootWindow(window, popup_hierarchy);
+ ImGuiWindow* window_root = GetCombinedRootWindow(window, popup_hierarchy, dock_hierarchy);
if (window_root == potential_parent)
return true;
while (window != NULL)
@@ -7836,12 +8401,13 @@
{
IM_ASSERT(cur_window); // Not inside a Begin()/End()
const bool popup_hierarchy = (flags & ImGuiHoveredFlags_NoPopupHierarchy) == 0;
+ const bool dock_hierarchy = (flags & ImGuiHoveredFlags_DockHierarchy) != 0;
if (flags & ImGuiHoveredFlags_RootWindow)
- cur_window = GetCombinedRootWindow(cur_window, popup_hierarchy);
+ cur_window = GetCombinedRootWindow(cur_window, popup_hierarchy, dock_hierarchy);
bool result;
if (flags & ImGuiHoveredFlags_ChildWindows)
- result = IsWindowChildOf(ref_window, cur_window, popup_hierarchy);
+ result = IsWindowChildOf(ref_window, cur_window, popup_hierarchy, dock_hierarchy);
else
result = (ref_window == cur_window);
if (!result)
@@ -7880,15 +8446,28 @@
IM_ASSERT(cur_window); // Not inside a Begin()/End()
const bool popup_hierarchy = (flags & ImGuiFocusedFlags_NoPopupHierarchy) == 0;
+ const bool dock_hierarchy = (flags & ImGuiFocusedFlags_DockHierarchy) != 0;
if (flags & ImGuiHoveredFlags_RootWindow)
- cur_window = GetCombinedRootWindow(cur_window, popup_hierarchy);
+ cur_window = GetCombinedRootWindow(cur_window, popup_hierarchy, dock_hierarchy);
if (flags & ImGuiHoveredFlags_ChildWindows)
- return IsWindowChildOf(ref_window, cur_window, popup_hierarchy);
+ return IsWindowChildOf(ref_window, cur_window, popup_hierarchy, dock_hierarchy);
else
return (ref_window == cur_window);
}
+ImGuiID ImGui::GetWindowDockID()
+{
+ ImGuiContext& g = *GImGui;
+ return g.CurrentWindow->DockId;
+}
+
+bool ImGui::IsWindowDocked()
+{
+ ImGuiContext& g = *GImGui;
+ return g.CurrentWindow->DockIsActive;
+}
+
// Can we focus this window with CTRL+TAB (or PadMenu + PadFocusPrev/PadFocusNext)
// Note that NoNavFocus makes the window not reachable with CTRL+TAB but it can still be focused with mouse or programmatically.
// If you want a window to never be focused, you may use the e.g. NoInputs flag.
@@ -7933,6 +8512,7 @@
if (offset.x == 0.0f && offset.y == 0.0f)
return;
MarkIniSettingsDirty(window);
+ // FIXME: share code with TranslateWindow(), need to confirm whether the 3 rect modified by TranslateWindow() are desirable here.
window->DC.CursorPos += offset; // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
window->DC.CursorMaxPos += offset; // And more importantly we need to offset CursorMaxPos/CursorStartPos this so ContentSize calculation doesn't get affected.
window->DC.IdealMaxPos += offset;
@@ -8070,6 +8650,7 @@
g.NextWindowData.PosVal = pos;
g.NextWindowData.PosPivotVal = pivot;
g.NextWindowData.PosCond = cond ? cond : ImGuiCond_Always;
+ g.NextWindowData.PosUndock = true;
}
void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)
@@ -8132,6 +8713,29 @@
g.NextWindowData.BgAlphaVal = alpha;
}
+void ImGui::SetNextWindowViewport(ImGuiID id)
+{
+ ImGuiContext& g = *GImGui;
+ g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasViewport;
+ g.NextWindowData.ViewportId = id;
+}
+
+void ImGui::SetNextWindowDockID(ImGuiID id, ImGuiCond cond)
+{
+ ImGuiContext& g = *GImGui;
+ g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasDock;
+ g.NextWindowData.DockCond = cond ? cond : ImGuiCond_Always;
+ g.NextWindowData.DockId = id;
+}
+
+void ImGui::SetNextWindowClass(const ImGuiWindowClass* window_class)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT((window_class->ViewportFlagsOverrideSet & window_class->ViewportFlagsOverrideClear) == 0); // Cannot set both set and clear for the same bit
+ g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasWindowClass;
+ g.NextWindowData.WindowClass = *window_class;
+}
+
// This is experimental and meant to be a toy for exploring a future/wider range of features.
void ImGui::SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags)
{
@@ -8146,6 +8750,19 @@
return window->DrawList;
}
+float ImGui::GetWindowDpiScale()
+{
+ ImGuiContext& g = *GImGui;
+ return g.CurrentDpiScale;
+}
+
+ImGuiViewport* ImGui::GetWindowViewport()
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(g.CurrentViewport != NULL && g.CurrentViewport == g.CurrentWindow->Viewport);
+ return g.CurrentViewport;
+}
+
ImFont* ImGui::GetFont()
{
return GImGui->Font;
@@ -9149,6 +9766,8 @@
// Hit testing, expanded for touch input
if (!rect_clipped.ContainsWithPad(g.IO.MousePos, g.Style.TouchExtraPadding))
return false;
+ if (!g.MouseViewport->GetMainRect().Overlaps(rect_clipped))
+ return false;
return true;
}
@@ -9470,13 +10089,16 @@
io.MouseClickedTime[i] = g.Time;
io.MouseClickedPos[i] = io.MousePos;
io.MouseClickedCount[i] = io.MouseClickedLastCount[i];
+ io.MouseDragMaxDistanceAbs[i] = ImVec2(0.0f, 0.0f);
io.MouseDragMaxDistanceSqr[i] = 0.0f;
}
else if (io.MouseDown[i])
{
// Maintain the maximum distance we reaching from the initial click position, which is used with dragging threshold
- float delta_sqr_click_pos = IsMousePosValid(&io.MousePos) ? ImLengthSqr(io.MousePos - io.MouseClickedPos[i]) : 0.0f;
- io.MouseDragMaxDistanceSqr[i] = ImMax(io.MouseDragMaxDistanceSqr[i], delta_sqr_click_pos);
+ ImVec2 delta_from_click_pos = IsMousePosValid(&io.MousePos) ? (io.MousePos - io.MouseClickedPos[i]) : ImVec2(0.0f, 0.0f);
+ io.MouseDragMaxDistanceSqr[i] = ImMax(io.MouseDragMaxDistanceSqr[i], ImLengthSqr(delta_from_click_pos));
+ io.MouseDragMaxDistanceAbs[i].x = ImMax(io.MouseDragMaxDistanceAbs[i].x, delta_from_click_pos.x < 0.0f ? -delta_from_click_pos.x : delta_from_click_pos.x);
+ io.MouseDragMaxDistanceAbs[i].y = ImMax(io.MouseDragMaxDistanceAbs[i].y, delta_from_click_pos.y < 0.0f ? -delta_from_click_pos.y : delta_from_click_pos.y);
}
// We provide io.MouseDoubleClicked[] as a legacy service
@@ -9666,6 +10288,7 @@
if (e->Type == ImGuiInputEventType_MousePos) { if (e->MousePos.PosX == -FLT_MAX && e->MousePos.PosY == -FLT_MAX) IMGUI_DEBUG_LOG_IO("[io] %s: MousePos (-FLT_MAX, -FLT_MAX)\n", prefix); else IMGUI_DEBUG_LOG_IO("[io] %s: MousePos (%.1f, %.1f) (%s)\n", prefix, e->MousePos.PosX, e->MousePos.PosY, GetMouseSourceName(e->MousePos.MouseSource)); return; }
if (e->Type == ImGuiInputEventType_MouseButton) { IMGUI_DEBUG_LOG_IO("[io] %s: MouseButton %d %s (%s)\n", prefix, e->MouseButton.Button, e->MouseButton.Down ? "Down" : "Up", GetMouseSourceName(e->MouseButton.MouseSource)); return; }
if (e->Type == ImGuiInputEventType_MouseWheel) { IMGUI_DEBUG_LOG_IO("[io] %s: MouseWheel (%.3f, %.3f) (%s)\n", prefix, e->MouseWheel.WheelX, e->MouseWheel.WheelY, GetMouseSourceName(e->MouseWheel.MouseSource)); return; }
+ if (e->Type == ImGuiInputEventType_MouseViewport){IMGUI_DEBUG_LOG_IO("[io] %s: MouseViewport (0x%08X)\n", prefix, e->MouseViewport.HoveredViewportID); return; }
if (e->Type == ImGuiInputEventType_Key) { IMGUI_DEBUG_LOG_IO("[io] %s: Key \"%s\" %s\n", prefix, ImGui::GetKeyName(e->Key.Key), e->Key.Down ? "Down" : "Up"); return; }
if (e->Type == ImGuiInputEventType_Text) { IMGUI_DEBUG_LOG_IO("[io] %s: Text: %c (U+%08X)\n", prefix, e->Text.Char, e->Text.Char); return; }
if (e->Type == ImGuiInputEventType_Focus) { IMGUI_DEBUG_LOG_IO("[io] %s: AppFocused %d\n", prefix, e->AppFocused.Focused); return; }
@@ -9729,6 +10352,10 @@
io.MouseSource = e->MouseWheel.MouseSource;
mouse_wheeled = true;
}
+ else if (e->Type == ImGuiInputEventType_MouseViewport)
+ {
+ io.MouseHoveredViewport = e->MouseViewport.HoveredViewportID;
+ }
else if (e->Type == ImGuiInputEventType_Key)
{
// Trickling Rule: Stop processing queued events if we got multiple action on the same button
@@ -10126,6 +10753,45 @@
if (g.IO.SetClipboardTextFn != NULL && (g.PlatformIO.Platform_SetClipboardTextFn == NULL || g.PlatformIO.Platform_SetClipboardTextFn == Platform_SetClipboardTextFn_DefaultImpl))
g.PlatformIO.Platform_SetClipboardTextFn = [](ImGuiContext* ctx, const char* text) { return ctx->IO.SetClipboardTextFn(ctx->IO.ClipboardUserData, text); };
#endif
+
+ // Perform simple check: error if Docking or Viewport are enabled _exactly_ on frame 1 (instead of frame 0 or later), which is a common error leading to loss of .ini data.
+ if (g.FrameCount == 1 && (g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable) && (g.ConfigFlagsLastFrame & ImGuiConfigFlags_DockingEnable) == 0)
+ IM_ASSERT(0 && "Please set DockingEnable before the first call to NewFrame()! Otherwise you will lose your .ini settings!");
+ if (g.FrameCount == 1 && (g.IO.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) && (g.ConfigFlagsLastFrame & ImGuiConfigFlags_ViewportsEnable) == 0)
+ IM_ASSERT(0 && "Please set ViewportsEnable before the first call to NewFrame()! Otherwise you will lose your .ini settings!");
+
+ // Perform simple checks: multi-viewport and platform windows support
+ if (g.IO.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+ {
+ if ((g.IO.BackendFlags & ImGuiBackendFlags_PlatformHasViewports) && (g.IO.BackendFlags & ImGuiBackendFlags_RendererHasViewports))
+ {
+ IM_ASSERT((g.FrameCount == 0 || g.FrameCount == g.FrameCountPlatformEnded) && "Forgot to call UpdatePlatformWindows() in main loop after EndFrame()? Check examples/ applications for reference.");
+ IM_ASSERT(g.PlatformIO.Platform_CreateWindow != NULL && "Platform init didn't install handlers?");
+ IM_ASSERT(g.PlatformIO.Platform_DestroyWindow != NULL && "Platform init didn't install handlers?");
+ IM_ASSERT(g.PlatformIO.Platform_GetWindowPos != NULL && "Platform init didn't install handlers?");
+ IM_ASSERT(g.PlatformIO.Platform_SetWindowPos != NULL && "Platform init didn't install handlers?");
+ IM_ASSERT(g.PlatformIO.Platform_GetWindowSize != NULL && "Platform init didn't install handlers?");
+ IM_ASSERT(g.PlatformIO.Platform_SetWindowSize != NULL && "Platform init didn't install handlers?");
+ IM_ASSERT(g.PlatformIO.Monitors.Size > 0 && "Platform init didn't setup Monitors list?");
+ IM_ASSERT((g.Viewports[0]->PlatformUserData != NULL || g.Viewports[0]->PlatformHandle != NULL) && "Platform init didn't setup main viewport.");
+ if (g.IO.ConfigDockingTransparentPayload && (g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
+ IM_ASSERT(g.PlatformIO.Platform_SetWindowAlpha != NULL && "Platform_SetWindowAlpha handler is required to use io.ConfigDockingTransparent!");
+ }
+ else
+ {
+ // Disable feature, our backends do not support it
+ g.IO.ConfigFlags &= ~ImGuiConfigFlags_ViewportsEnable;
+ }
+
+ // Perform simple checks on platform monitor data + compute a total bounding box for quick early outs
+ for (ImGuiPlatformMonitor& mon : g.PlatformIO.Monitors)
+ {
+ IM_UNUSED(mon);
+ IM_ASSERT(mon.MainSize.x > 0.0f && mon.MainSize.y > 0.0f && "Monitor main bounds not setup properly.");
+ IM_ASSERT(ImRect(mon.MainPos, mon.MainPos + mon.MainSize).Contains(ImRect(mon.WorkPos, mon.WorkPos + mon.WorkSize)) && "Monitor work bounds not setup properly. If you don't have work area information, just copy MainPos/MainSize into them.");
+ IM_ASSERT(mon.DpiScale != 0.0f);
+ }
+ }
}
static void ImGui::ErrorCheckEndFrameSanityChecks()
@@ -11129,7 +11795,7 @@
SetWindowHiddenAndSkipItemsForCurrentFrame(window);
ImFormatString(window_name, IM_ARRAYSIZE(window_name), "##Tooltip_%02d", ++g.TooltipOverrideCount);
}
- ImGuiWindowFlags flags = ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_AlwaysAutoResize;
+ ImGuiWindowFlags flags = ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDocking;
Begin(window_name, NULL, flags | extra_window_flags);
// 2023-03-09: Added bool return value to the API, but currently always returning true.
// If this ever returns false we need to update BeginDragDropSource() accordingly.
@@ -11202,8 +11868,8 @@
if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
{
// Return true if the popup is open anywhere in the popup stack
- for (int n = 0; n < g.OpenPopupStack.Size; n++)
- if (g.OpenPopupStack[n].PopupId == id)
+ for (ImGuiPopupData& popup_data : g.OpenPopupStack)
+ if (popup_data.PopupId == id)
return true;
return false;
}
@@ -11342,12 +12008,13 @@
// Window -> Popup1 -> Window2(Ref)
// - Clicking/focusing Popup1 will close Popup2 and Popup3:
// Window -> Popup1(Ref) -> Popup2 -> Popup3
- // - Each popups may contain child windows, which is why we compare ->RootWindow!
+ // - Each popups may contain child windows, which is why we compare ->RootWindowDockTree!
// Window -> Popup1 -> Popup1_Child -> Popup2 -> Popup2_Child
// We step through every popup from bottom to top to validate their position relative to reference window.
bool ref_window_is_descendent_of_popup = false;
for (int n = popup_count_to_keep; n < g.OpenPopupStack.Size; n++)
if (ImGuiWindow* popup_window = g.OpenPopupStack[n].Window)
+ //if (popup_window->RootWindowDockTree == ref_window->RootWindowDockTree) // FIXME-MERGE
if (IsWindowWithinBeginStackOf(ref_window, popup_window))
{
ref_window_is_descendent_of_popup = true;
@@ -11451,7 +12118,7 @@
else
ImFormatString(name, IM_ARRAYSIZE(name), "##Popup_%08x", id); // Not recycling, so we can close/open during the same frame
- bool is_open = Begin(name, NULL, extra_window_flags | ImGuiWindowFlags_Popup);
+ bool is_open = Begin(name, NULL, extra_window_flags | ImGuiWindowFlags_Popup | ImGuiWindowFlags_NoDocking);
if (!is_open) // NB: Begin can return false when the popup is completely clipped (e.g. zero size display)
EndPopup();
@@ -11495,11 +12162,11 @@
// FIXME: Should test for (PosCond & window->SetWindowPosAllowFlags) with the upcoming window.
if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)
{
- const ImGuiViewport* viewport = GetMainViewport();
+ const ImGuiViewport* viewport = window->WasActive ? window->Viewport : GetMainViewport(); // FIXME-VIEWPORT: What may be our reference viewport?
SetNextWindowPos(viewport->GetCenter(), ImGuiCond_FirstUseEver, ImVec2(0.5f, 0.5f));
}
- flags |= ImGuiWindowFlags_Popup | ImGuiWindowFlags_Modal | ImGuiWindowFlags_NoCollapse;
+ flags |= ImGuiWindowFlags_Popup | ImGuiWindowFlags_Modal | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoDocking;
const bool is_open = Begin(name, p_open, flags);
if (!is_open || (p_open && !*p_open)) // NB: is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
{
@@ -11686,8 +12353,19 @@
ImRect ImGui::GetPopupAllowedExtentRect(ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
- IM_UNUSED(window);
- ImRect r_screen = ((ImGuiViewportP*)(void*)GetMainViewport())->GetMainRect();
+ ImRect r_screen;
+ if (window->ViewportAllowPlatformMonitorExtend >= 0)
+ {
+ // Extent with be in the frame of reference of the given viewport (so Min is likely to be negative here)
+ const ImGuiPlatformMonitor& monitor = g.PlatformIO.Monitors[window->ViewportAllowPlatformMonitorExtend];
+ r_screen.Min = monitor.WorkPos;
+ r_screen.Max = monitor.WorkPos + monitor.WorkSize;
+ }
+ else
+ {
+ // Use the full viewport area (not work area) for popups
+ r_screen = window->Viewport->GetMainRect();
+ }
ImVec2 padding = g.Style.DisplaySafeAreaPadding;
r_screen.Expand(ImVec2((r_screen.GetWidth() > padding.x * 2) ? -padding.x : 0.0f, (r_screen.GetHeight() > padding.y * 2) ? -padding.y : 0.0f));
return r_screen;
@@ -11702,8 +12380,7 @@
{
// Child menus typically request _any_ position within the parent menu item, and then we move the new menu outside the parent bounds.
// This is how we end up with child menus appearing (most-commonly) on the right of the parent menu.
- IM_ASSERT(g.CurrentWindow == window);
- ImGuiWindow* parent_window = g.CurrentWindowStack[g.CurrentWindowStack.Size - 2].Window;
+ ImGuiWindow* parent_window = window->ParentWindow;
float horizontal_overlap = g.Style.ItemInnerSpacing.x; // We want some overlap to convey the relative depth of each menu (currently the amount of overlap is hard-coded to style.ItemSpacing.x).
ImRect r_avoid;
if (parent_window->DC.MenuBarAppending)
@@ -12245,6 +12922,9 @@
{
if (window->NavLastChildNavWindow && window->NavLastChildNavWindow->WasActive)
return window->NavLastChildNavWindow;
+ if (window->DockNodeAsHost && window->DockNodeAsHost->TabBar)
+ if (ImGuiTabItem* tab = TabBarFindMostRecentlySelectedTabForActiveWindow(window->DockNodeAsHost->TabBar))
+ return tab->Window;
return window;
}
@@ -12289,6 +12969,7 @@
// This needs to be called before we submit any widget (aka in or before Begin)
void ImGui::NavInitWindow(ImGuiWindow* window, bool force_reinit)
{
+ // FIXME: ChildWindow test here is wrong for docking
ImGuiContext& g = *GImGui;
IM_ASSERT(window == g.NavWindow);
@@ -12349,7 +13030,7 @@
ref_rect.Translate(window->Scroll - next_scroll);
}
ImVec2 pos = ImVec2(ref_rect.Min.x + ImMin(g.Style.FramePadding.x * 4, ref_rect.GetWidth()), ref_rect.Max.y - ImMin(g.Style.FramePadding.y, ref_rect.GetHeight()));
- ImGuiViewport* viewport = GetMainViewport();
+ ImGuiViewport* viewport = window->Viewport;
return ImTrunc(ImClamp(pos, viewport->Pos, viewport->Pos + viewport->Size)); // ImTrunc() is important because non-integer mouse position application in backend might be lossy and result in undesirable non-zero delta.
}
}
@@ -13228,7 +13909,7 @@
ImVec2 accum_floored = ImTrunc(g.NavWindowingAccumDeltaPos);
if (accum_floored.x != 0.0f || accum_floored.y != 0.0f)
{
- ImGuiWindow* moving_window = g.NavWindowingTarget->RootWindow;
+ ImGuiWindow* moving_window = g.NavWindowingTarget->RootWindowDockTree;
SetWindowPos(moving_window, moving_window->Pos + accum_floored, ImGuiCond_Always);
g.NavWindowingAccumDeltaPos -= accum_floored;
}
@@ -13238,6 +13919,9 @@
// Apply final focus
if (apply_focus_window && (g.NavWindow == NULL || apply_focus_window != g.NavWindow->RootWindow))
{
+ // FIXME: Many actions here could be part of a higher-level/reused function. Why aren't they in FocusWindow()
+ // Investigate for each of them: ClearActiveID(), NavRestoreHighlightAfterMove(), NavRestoreLastChildNavWindow(), ClosePopupsOverWindow(), NavInitWindow()
+ ImGuiViewport* previous_viewport = g.NavWindow ? g.NavWindow->Viewport : NULL;
ClearActiveID();
NavRestoreHighlightAfterMove();
ClosePopupsOverWindow(apply_focus_window, false);
@@ -13255,6 +13939,10 @@
// won't be valid.
if (apply_focus_window->DC.NavLayersActiveMaskNext == (1 << ImGuiNavLayer_Menu))
g.NavLayer = ImGuiNavLayer_Menu;
+
+ // Request OS level focus
+ if (apply_focus_window->Viewport != previous_viewport && g.PlatformIO.Platform_SetWindowFocus)
+ g.PlatformIO.Platform_SetWindowFocus(apply_focus_window->Viewport);
}
if (apply_focus_window)
g.NavWindowingTarget = NULL;
@@ -13283,7 +13971,8 @@
if (new_nav_layer != g.NavLayer)
{
// Reinitialize navigation when entering menu bar with the Alt key (FIXME: could be a properly of the layer?)
- if (new_nav_layer == ImGuiNavLayer_Menu)
+ const bool preserve_layer_1_nav_id = (new_nav_window->DockNodeAsHost != NULL);
+ if (new_nav_layer == ImGuiNavLayer_Menu && !preserve_layer_1_nav_id)
g.NavWindow->NavLastIds[new_nav_layer] = 0;
NavRestoreLayer(new_nav_layer);
NavRestoreHighlightAfterMove();
@@ -13298,6 +13987,8 @@
return ImGui::LocalizeGetMsg(ImGuiLocKey_WindowingPopup);
if ((window->Flags & ImGuiWindowFlags_MenuBar) && strcmp(window->Name, "##MainMenuBar") == 0)
return ImGui::LocalizeGetMsg(ImGuiLocKey_WindowingMainMenuBar);
+ if (window->DockNodeAsHost)
+ return "(Dock node)"; // Not normally shown to user.
return ImGui::LocalizeGetMsg(ImGuiLocKey_WindowingUntitled);
}
@@ -13312,7 +14003,7 @@
if (g.NavWindowingListWindow == NULL)
g.NavWindowingListWindow = FindWindowByName("###NavWindowingList");
- const ImGuiViewport* viewport = GetMainViewport();
+ const ImGuiViewport* viewport = /*g.NavWindow ? g.NavWindow->Viewport :*/ GetMainViewport();
SetNextWindowSizeConstraints(ImVec2(viewport->Size.x * 0.20f, viewport->Size.y * 0.20f), ImVec2(FLT_MAX, FLT_MAX));
SetNextWindowPos(viewport->GetCenter(), ImGuiCond_Always, ImVec2(0.5f, 0.5f));
PushStyleVar(ImGuiStyleVar_WindowPadding, g.Style.WindowPadding * 2.0f);
@@ -13563,7 +14254,7 @@
ImGuiWindow* window = g.CurrentWindow;
ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
- if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
+ if (hovered_window == NULL || window->RootWindowDockTree != hovered_window->RootWindowDockTree)
return false;
IM_ASSERT(id != 0);
if (!IsMouseHoveringRect(bb.Min, bb.Max) || (id == g.DragDropPayload.SourceId))
@@ -13593,7 +14284,7 @@
if (!(g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredRect))
return false;
ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
- if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow || window->SkipItems)
+ if (hovered_window == NULL || window->RootWindowDockTree != hovered_window->RootWindowDockTree || window->SkipItems)
return false;
const ImRect& display_rect = (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HasDisplayRect) ? g.LastItemData.DisplayRect : g.LastItemData.Rect;
@@ -14198,11 +14889,14 @@
void ImGui::ClearWindowSettings(const char* name)
{
//IMGUI_DEBUG_LOG("ClearWindowSettings('%s')\n", name);
+ ImGuiContext& g = *GImGui;
ImGuiWindow* window = FindWindowByName(name);
if (window != NULL)
{
window->Flags |= ImGuiWindowFlags_NoSavedSettings;
InitOrLoadWindowSettings(window, NULL);
+ if (window->DockId != 0)
+ DockContextProcessUndockWindow(&g, window, true);
}
if (ImGuiWindowSettings* settings = window ? FindWindowSettingsByWindow(window) : FindWindowSettingsByID(ImHashStr(name)))
settings->WantDelete = true;
@@ -14234,10 +14928,16 @@
ImGuiWindowSettings* settings = (ImGuiWindowSettings*)entry;
int x, y;
int i;
- if (sscanf(line, "Pos=%i,%i", &x, &y) == 2) { settings->Pos = ImVec2ih((short)x, (short)y); }
- else if (sscanf(line, "Size=%i,%i", &x, &y) == 2) { settings->Size = ImVec2ih((short)x, (short)y); }
- else if (sscanf(line, "Collapsed=%d", &i) == 1) { settings->Collapsed = (i != 0); }
- else if (sscanf(line, "IsChild=%d", &i) == 1) { settings->IsChild = (i != 0); }
+ ImU32 u1;
+ if (sscanf(line, "Pos=%i,%i", &x, &y) == 2) { settings->Pos = ImVec2ih((short)x, (short)y); }
+ else if (sscanf(line, "Size=%i,%i", &x, &y) == 2) { settings->Size = ImVec2ih((short)x, (short)y); }
+ else if (sscanf(line, "ViewportId=0x%08X", &u1) == 1) { settings->ViewportId = u1; }
+ else if (sscanf(line, "ViewportPos=%i,%i", &x, &y) == 2){ settings->ViewportPos = ImVec2ih((short)x, (short)y); }
+ else if (sscanf(line, "Collapsed=%d", &i) == 1) { settings->Collapsed = (i != 0); }
+ else if (sscanf(line, "IsChild=%d", &i) == 1) { settings->IsChild = (i != 0); }
+ else if (sscanf(line, "DockId=0x%X,%d", &u1, &i) == 2) { settings->DockId = u1; settings->DockOrder = (short)i; }
+ else if (sscanf(line, "DockId=0x%X", &u1) == 1) { settings->DockId = u1; settings->DockOrder = -1; }
+ else if (sscanf(line, "ClassId=0x%X", &u1) == 1) { settings->ClassId = u1; }
}
// Apply to existing windows (if any)
@@ -14270,10 +14970,16 @@
window->SettingsOffset = g.SettingsWindows.offset_from_ptr(settings);
}
IM_ASSERT(settings->ID == window->ID);
- settings->Pos = ImVec2ih(window->Pos);
+ settings->Pos = ImVec2ih(window->Pos - window->ViewportPos);
settings->Size = ImVec2ih(window->SizeFull);
- settings->IsChild = (window->Flags & ImGuiWindowFlags_ChildWindow) != 0;
+ settings->ViewportId = window->ViewportId;
+ settings->ViewportPos = ImVec2ih(window->ViewportPos);
+ IM_ASSERT(window->DockNode == NULL || window->DockNode->ID == window->DockId);
+ settings->DockId = window->DockId;
+ settings->ClassId = window->WindowClass.ClassId;
+ settings->DockOrder = window->DockOrder;
settings->Collapsed = window->Collapsed;
+ settings->IsChild = (window->RootWindow != window); // Cannot rely on ImGuiWindowFlags_ChildWindow here as docked windows have this set.
settings->WantDelete = false;
}
@@ -14292,10 +14998,26 @@
}
else
{
- buf->appendf("Pos=%d,%d\n", settings->Pos.x, settings->Pos.y);
- buf->appendf("Size=%d,%d\n", settings->Size.x, settings->Size.y);
- if (settings->Collapsed)
- buf->appendf("Collapsed=1\n");
+ if (settings->ViewportId != 0 && settings->ViewportId != ImGui::IMGUI_VIEWPORT_DEFAULT_ID)
+ {
+ buf->appendf("ViewportPos=%d,%d\n", settings->ViewportPos.x, settings->ViewportPos.y);
+ buf->appendf("ViewportId=0x%08X\n", settings->ViewportId);
+ }
+ if (settings->Pos.x != 0 || settings->Pos.y != 0 || settings->ViewportId == ImGui::IMGUI_VIEWPORT_DEFAULT_ID)
+ buf->appendf("Pos=%d,%d\n", settings->Pos.x, settings->Pos.y);
+ if (settings->Size.x != 0 || settings->Size.y != 0)
+ buf->appendf("Size=%d,%d\n", settings->Size.x, settings->Size.y);
+ buf->appendf("Collapsed=%d\n", settings->Collapsed);
+ if (settings->DockId != 0)
+ {
+ //buf->appendf("TabId=0x%08X\n", ImHashStr("#TAB", 4, settings->ID)); // window->TabId: this is not read back but writing it makes "debugging" the .ini data easier.
+ if (settings->DockOrder == -1)
+ buf->appendf("DockId=0x%08X\n", settings->DockId);
+ else
+ buf->appendf("DockId=0x%08X,%d\n", settings->DockId, settings->DockOrder);
+ if (settings->ClassId != 0)
+ buf->appendf("ClassId=0x%08X\n", settings->ClassId);
+ }
}
buf->append("\n");
}
@@ -14318,9 +15040,28 @@
// [SECTION] VIEWPORTS, PLATFORM WINDOWS
//-----------------------------------------------------------------------------
// - GetMainViewport()
+// - FindViewportByID()
+// - FindViewportByPlatformHandle()
+// - SetCurrentViewport() [Internal]
// - SetWindowViewport() [Internal]
+// - GetWindowAlwaysWantOwnViewport() [Internal]
+// - UpdateTryMergeWindowIntoHostViewport() [Internal]
+// - UpdateTryMergeWindowIntoHostViewports() [Internal]
+// - TranslateWindowsInViewport() [Internal]
+// - ScaleWindowsInViewport() [Internal]
+// - FindHoveredViewportFromPlatformWindowStack() [Internal]
// - UpdateViewportsNewFrame() [Internal]
-// (this section is more complete in the 'docking' branch)
+// - UpdateViewportsEndFrame() [Internal]
+// - AddUpdateViewport() [Internal]
+// - WindowSelectViewport() [Internal]
+// - WindowSyncOwnedViewport() [Internal]
+// - UpdatePlatformWindows()
+// - RenderPlatformWindowsDefault()
+// - FindPlatformMonitorForPos() [Internal]
+// - FindPlatformMonitorForRect() [Internal]
+// - UpdateViewportPlatformMonitor() [Internal]
+// - DestroyPlatformWindow() [Internal]
+// - DestroyPlatformWindows()
//-----------------------------------------------------------------------------
ImGuiViewport* ImGui::GetMainViewport()
@@ -14329,40 +15070,4924 @@
return g.Viewports[0];
}
+// FIXME: This leaks access to viewports not listed in PlatformIO.Viewports[]. Problematic? (#4236)
+ImGuiViewport* ImGui::FindViewportByID(ImGuiID id)
+{
+ ImGuiContext& g = *GImGui;
+ for (ImGuiViewportP* viewport : g.Viewports)
+ if (viewport->ID == id)
+ return viewport;
+ return NULL;
+}
+
+ImGuiViewport* ImGui::FindViewportByPlatformHandle(void* platform_handle)
+{
+ ImGuiContext& g = *GImGui;
+ for (ImGuiViewportP* viewport : g.Viewports)
+ if (viewport->PlatformHandle == platform_handle)
+ return viewport;
+ return NULL;
+}
+
+void ImGui::SetCurrentViewport(ImGuiWindow* current_window, ImGuiViewportP* viewport)
+{
+ ImGuiContext& g = *GImGui;
+ (void)current_window;
+
+ if (viewport)
+ viewport->LastFrameActive = g.FrameCount;
+ if (g.CurrentViewport == viewport)
+ return;
+ g.CurrentDpiScale = viewport ? viewport->DpiScale : 1.0f;
+ g.CurrentViewport = viewport;
+ //IMGUI_DEBUG_LOG_VIEWPORT("[viewport] SetCurrentViewport changed '%s' 0x%08X\n", current_window ? current_window->Name : NULL, viewport ? viewport->ID : 0);
+
+ // Notify platform layer of viewport changes
+ // FIXME-DPI: This is only currently used for experimenting with handling of multiple DPI
+ if (g.CurrentViewport && g.PlatformIO.Platform_OnChangedViewport)
+ g.PlatformIO.Platform_OnChangedViewport(g.CurrentViewport);
+}
+
void ImGui::SetWindowViewport(ImGuiWindow* window, ImGuiViewportP* viewport)
{
+ // Abandon viewport
+ if (window->ViewportOwned && window->Viewport->Window == window)
+ window->Viewport->Size = ImVec2(0.0f, 0.0f);
+
window->Viewport = viewport;
+ window->ViewportId = viewport->ID;
+ window->ViewportOwned = (viewport->Window == window);
+}
+
+static bool ImGui::GetWindowAlwaysWantOwnViewport(ImGuiWindow* window)
+{
+ // Tooltips and menus are not automatically forced into their own viewport when the NoMerge flag is set, however the multiplication of viewports makes them more likely to protrude and create their own.
+ ImGuiContext& g = *GImGui;
+ if (g.IO.ConfigViewportsNoAutoMerge || (window->WindowClass.ViewportFlagsOverrideSet & ImGuiViewportFlags_NoAutoMerge))
+ if (g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable)
+ if (!window->DockIsActive)
+ if ((window->Flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_ChildMenu | ImGuiWindowFlags_Tooltip)) == 0)
+ if ((window->Flags & ImGuiWindowFlags_Popup) == 0 || (window->Flags & ImGuiWindowFlags_Modal) != 0)
+ return true;
+ return false;
+}
+
+static bool ImGui::UpdateTryMergeWindowIntoHostViewport(ImGuiWindow* window, ImGuiViewportP* viewport)
+{
+ ImGuiContext& g = *GImGui;
+ if (window->Viewport == viewport)
+ return false;
+ if ((viewport->Flags & ImGuiViewportFlags_CanHostOtherWindows) == 0)
+ return false;
+ if ((viewport->Flags & ImGuiViewportFlags_IsMinimized) != 0)
+ return false;
+ if (!viewport->GetMainRect().Contains(window->Rect()))
+ return false;
+ if (GetWindowAlwaysWantOwnViewport(window))
+ return false;
+
+ // FIXME: Can't use g.WindowsFocusOrder[] for root windows only as we care about Z order. If we maintained a DisplayOrder along with FocusOrder we could..
+ for (ImGuiWindow* window_behind : g.Windows)
+ {
+ if (window_behind == window)
+ break;
+ if (window_behind->WasActive && window_behind->ViewportOwned && !(window_behind->Flags & ImGuiWindowFlags_ChildWindow))
+ if (window_behind->Viewport->GetMainRect().Overlaps(window->Rect()))
+ return false;
+ }
+
+ // Move to the existing viewport, Move child/hosted windows as well (FIXME-OPT: iterate child)
+ ImGuiViewportP* old_viewport = window->Viewport;
+ if (window->ViewportOwned)
+ for (int n = 0; n < g.Windows.Size; n++)
+ if (g.Windows[n]->Viewport == old_viewport)
+ SetWindowViewport(g.Windows[n], viewport);
+ SetWindowViewport(window, viewport);
+ BringWindowToDisplayFront(window);
+
+ return true;
+}
+
+// FIXME: handle 0 to N host viewports
+static bool ImGui::UpdateTryMergeWindowIntoHostViewports(ImGuiWindow* window)
+{
+ ImGuiContext& g = *GImGui;
+ return UpdateTryMergeWindowIntoHostViewport(window, g.Viewports[0]);
+}
+
+// Translate Dear ImGui windows when a Host Viewport has been moved
+// (This additionally keeps windows at the same place when ImGuiConfigFlags_ViewportsEnable is toggled!)
+void ImGui::TranslateWindowsInViewport(ImGuiViewportP* viewport, const ImVec2& old_pos, const ImVec2& new_pos)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(viewport->Window == NULL && (viewport->Flags & ImGuiViewportFlags_CanHostOtherWindows));
+
+ // 1) We test if ImGuiConfigFlags_ViewportsEnable was just toggled, which allows us to conveniently
+ // translate imgui windows from OS-window-local to absolute coordinates or vice-versa.
+ // 2) If it's not going to fit into the new size, keep it at same absolute position.
+ // One problem with this is that most Win32 applications doesn't update their render while dragging,
+ // and so the window will appear to teleport when releasing the mouse.
+ const bool translate_all_windows = (g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable) != (g.ConfigFlagsLastFrame & ImGuiConfigFlags_ViewportsEnable);
+ ImRect test_still_fit_rect(old_pos, old_pos + viewport->Size);
+ ImVec2 delta_pos = new_pos - old_pos;
+ for (ImGuiWindow* window : g.Windows) // FIXME-OPT
+ if (translate_all_windows || (window->Viewport == viewport && test_still_fit_rect.Contains(window->Rect())))
+ TranslateWindow(window, delta_pos);
+}
+
+// Scale all windows (position, size). Use when e.g. changing DPI. (This is a lossy operation!)
+void ImGui::ScaleWindowsInViewport(ImGuiViewportP* viewport, float scale)
+{
+ ImGuiContext& g = *GImGui;
+ if (viewport->Window)
+ {
+ ScaleWindow(viewport->Window, scale);
+ }
+ else
+ {
+ for (ImGuiWindow* window : g.Windows)
+ if (window->Viewport == viewport)
+ ScaleWindow(window, scale);
+ }
+}
+
+// If the backend doesn't set MouseLastHoveredViewport or doesn't honor ImGuiViewportFlags_NoInputs, we do a search ourselves.
+// A) It won't take account of the possibility that non-imgui windows may be in-between our dragged window and our target window.
+// B) It requires Platform_GetWindowFocus to be implemented by backend.
+ImGuiViewportP* ImGui::FindHoveredViewportFromPlatformWindowStack(const ImVec2& mouse_platform_pos)
+{
+ ImGuiContext& g = *GImGui;
+ ImGuiViewportP* best_candidate = NULL;
+ for (ImGuiViewportP* viewport : g.Viewports)
+ if (!(viewport->Flags & (ImGuiViewportFlags_NoInputs | ImGuiViewportFlags_IsMinimized)) && viewport->GetMainRect().Contains(mouse_platform_pos))
+ if (best_candidate == NULL || best_candidate->LastFocusedStampCount < viewport->LastFocusedStampCount)
+ best_candidate = viewport;
+ return best_candidate;
}
// Update viewports and monitor infos
+// Note that this is running even if 'ImGuiConfigFlags_ViewportsEnable' is not set, in order to clear unused viewports (if any) and update monitor info.
static void ImGui::UpdateViewportsNewFrame()
{
ImGuiContext& g = *GImGui;
- IM_ASSERT(g.Viewports.Size == 1);
+ IM_ASSERT(g.PlatformIO.Viewports.Size <= g.Viewports.Size);
- // Update main viewport with current platform position.
+ // Update Minimized status (we need it first in order to decide if we'll apply Pos/Size of the main viewport)
+ // Update Focused status
+ const bool viewports_enabled = (g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable) != 0;
+ if (viewports_enabled)
+ {
+ ImGuiViewportP* focused_viewport = NULL;
+ for (ImGuiViewportP* viewport : g.Viewports)
+ {
+ const bool platform_funcs_available = viewport->PlatformWindowCreated;
+ if (g.PlatformIO.Platform_GetWindowMinimized && platform_funcs_available)
+ {
+ bool is_minimized = g.PlatformIO.Platform_GetWindowMinimized(viewport);
+ if (is_minimized)
+ viewport->Flags |= ImGuiViewportFlags_IsMinimized;
+ else
+ viewport->Flags &= ~ImGuiViewportFlags_IsMinimized;
+ }
+
+ // Update our implicit z-order knowledge of platform windows, which is used when the backend cannot provide io.MouseHoveredViewport.
+ // When setting Platform_GetWindowFocus, it is expected that the platform backend can handle calls without crashing if it doesn't have data stored.
+ if (g.PlatformIO.Platform_GetWindowFocus && platform_funcs_available)
+ {
+ bool is_focused = g.PlatformIO.Platform_GetWindowFocus(viewport);
+ if (is_focused)
+ viewport->Flags |= ImGuiViewportFlags_IsFocused;
+ else
+ viewport->Flags &= ~ImGuiViewportFlags_IsFocused;
+ if (is_focused)
+ focused_viewport = viewport;
+ }
+ }
+
+ // Focused viewport has changed?
+ if (focused_viewport && g.PlatformLastFocusedViewportId != focused_viewport->ID)
+ {
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Focused viewport changed %08X -> %08X, attempting to apply our focus.\n", g.PlatformLastFocusedViewportId, focused_viewport->ID);
+ const ImGuiViewport* prev_focused_viewport = FindViewportByID(g.PlatformLastFocusedViewportId);
+ const bool prev_focused_has_been_destroyed = (prev_focused_viewport == NULL) || (prev_focused_viewport->PlatformWindowCreated == false);
+
+ // Store a tag so we can infer z-order easily from all our windows
+ // We compare PlatformLastFocusedViewportId so newly created viewports with _NoFocusOnAppearing flag
+ // will keep the front most stamp instead of losing it back to their parent viewport.
+ if (focused_viewport->LastFocusedStampCount != g.ViewportFocusedStampCount)
+ focused_viewport->LastFocusedStampCount = ++g.ViewportFocusedStampCount;
+ g.PlatformLastFocusedViewportId = focused_viewport->ID;
+
+ // Focus associated dear imgui window
+ // - if focus didn't happen with a click within imgui boundaries, e.g. Clicking platform title bar. (#6299)
+ // - if focus didn't happen because we destroyed another window (#6462)
+ // FIXME: perhaps 'FocusTopMostWindowUnderOne()' can handle the 'focused_window->Window != NULL' case as well.
+ const bool apply_imgui_focus_on_focused_viewport = !IsAnyMouseDown() && !prev_focused_has_been_destroyed;
+ if (apply_imgui_focus_on_focused_viewport)
+ {
+ focused_viewport->LastFocusedHadNavWindow |= (g.NavWindow != NULL) && (g.NavWindow->Viewport == focused_viewport); // Update so a window changing viewport won't lose focus.
+ ImGuiFocusRequestFlags focus_request_flags = ImGuiFocusRequestFlags_UnlessBelowModal | ImGuiFocusRequestFlags_RestoreFocusedChild;
+ if (focused_viewport->Window != NULL)
+ FocusWindow(focused_viewport->Window, focus_request_flags);
+ else if (focused_viewport->LastFocusedHadNavWindow)
+ FocusTopMostWindowUnderOne(NULL, NULL, focused_viewport, focus_request_flags); // Focus top most in viewport
+ else
+ FocusWindow(NULL, focus_request_flags); // No window had focus last time viewport was focused
+ }
+ }
+ if (focused_viewport)
+ focused_viewport->LastFocusedHadNavWindow = (g.NavWindow != NULL) && (g.NavWindow->Viewport == focused_viewport);
+ }
+
+ // Create/update main viewport with current platform position.
// FIXME-VIEWPORT: Size is driven by backend/user code for backward-compatibility but we should aim to make this more consistent.
ImGuiViewportP* main_viewport = g.Viewports[0];
- main_viewport->Flags = ImGuiViewportFlags_IsPlatformWindow | ImGuiViewportFlags_OwnedByApp;
- main_viewport->Pos = ImVec2(0.0f, 0.0f);
- main_viewport->Size = g.IO.DisplaySize;
-
- for (ImGuiViewportP* viewport : g.Viewports)
+ IM_ASSERT(main_viewport->ID == IMGUI_VIEWPORT_DEFAULT_ID);
+ IM_ASSERT(main_viewport->Window == NULL);
+ ImVec2 main_viewport_pos = viewports_enabled ? g.PlatformIO.Platform_GetWindowPos(main_viewport) : ImVec2(0.0f, 0.0f);
+ ImVec2 main_viewport_size = g.IO.DisplaySize;
+ if (viewports_enabled && (main_viewport->Flags & ImGuiViewportFlags_IsMinimized))
{
- // Lock down space taken by menu bars and status bars
+ main_viewport_pos = main_viewport->Pos; // Preserve last pos/size when minimized (FIXME: We don't do the same for Size outside of the viewport path)
+ main_viewport_size = main_viewport->Size;
+ }
+ AddUpdateViewport(NULL, IMGUI_VIEWPORT_DEFAULT_ID, main_viewport_pos, main_viewport_size, ImGuiViewportFlags_OwnedByApp | ImGuiViewportFlags_CanHostOtherWindows);
+
+ g.CurrentDpiScale = 0.0f;
+ g.CurrentViewport = NULL;
+ g.MouseViewport = NULL;
+ for (int n = 0; n < g.Viewports.Size; n++)
+ {
+ ImGuiViewportP* viewport = g.Viewports[n];
+ viewport->Idx = n;
+
+ // Erase unused viewports
+ if (n > 0 && viewport->LastFrameActive < g.FrameCount - 2)
+ {
+ DestroyViewport(viewport);
+ n--;
+ continue;
+ }
+
+ const bool platform_funcs_available = viewport->PlatformWindowCreated;
+ if (viewports_enabled)
+ {
+ // Update Position and Size (from Platform Window to ImGui) if requested.
+ // We do it early in the frame instead of waiting for UpdatePlatformWindows() to avoid a frame of lag when moving/resizing using OS facilities.
+ if (!(viewport->Flags & ImGuiViewportFlags_IsMinimized) && platform_funcs_available)
+ {
+ // Viewport->WorkPos and WorkSize will be updated below
+ if (viewport->PlatformRequestMove)
+ viewport->Pos = viewport->LastPlatformPos = g.PlatformIO.Platform_GetWindowPos(viewport);
+ if (viewport->PlatformRequestResize)
+ viewport->Size = viewport->LastPlatformSize = g.PlatformIO.Platform_GetWindowSize(viewport);
+ }
+ }
+
+ // Update/copy monitor info
+ UpdateViewportPlatformMonitor(viewport);
+
+ // Lock down space taken by menu bars and status bars + query initial insets from backend
// Setup initial value for functions like BeginMainMenuBar(), DockSpaceOverViewport() etc.
viewport->WorkInsetMin = viewport->BuildWorkInsetMin;
viewport->WorkInsetMax = viewport->BuildWorkInsetMax;
viewport->BuildWorkInsetMin = viewport->BuildWorkInsetMax = ImVec2(0.0f, 0.0f);
+ if (g.PlatformIO.Platform_GetWindowWorkAreaInsets != NULL && platform_funcs_available)
+ {
+ ImVec4 insets = g.PlatformIO.Platform_GetWindowWorkAreaInsets(viewport);
+ IM_ASSERT(insets.x >= 0.0f && insets.y >= 0.0f && insets.z >= 0.0f && insets.w >= 0.0f);
+ viewport->BuildWorkInsetMin = ImVec2(insets.x, insets.y);
+ viewport->BuildWorkInsetMax = ImVec2(insets.z, insets.w);
+ }
viewport->UpdateWorkRect();
+
+ // Reset alpha every frame. Users of transparency (docking) needs to request a lower alpha back.
+ viewport->Alpha = 1.0f;
+
+ // Translate Dear ImGui windows when a Host Viewport has been moved
+ // (This additionally keeps windows at the same place when ImGuiConfigFlags_ViewportsEnable is toggled!)
+ const ImVec2 viewport_delta_pos = viewport->Pos - viewport->LastPos;
+ if ((viewport->Flags & ImGuiViewportFlags_CanHostOtherWindows) && (viewport_delta_pos.x != 0.0f || viewport_delta_pos.y != 0.0f))
+ TranslateWindowsInViewport(viewport, viewport->LastPos, viewport->Pos);
+
+ // Update DPI scale
+ float new_dpi_scale;
+ if (g.PlatformIO.Platform_GetWindowDpiScale && platform_funcs_available)
+ new_dpi_scale = g.PlatformIO.Platform_GetWindowDpiScale(viewport);
+ else if (viewport->PlatformMonitor != -1)
+ new_dpi_scale = g.PlatformIO.Monitors[viewport->PlatformMonitor].DpiScale;
+ else
+ new_dpi_scale = (viewport->DpiScale != 0.0f) ? viewport->DpiScale : 1.0f;
+ if (viewport->DpiScale != 0.0f && new_dpi_scale != viewport->DpiScale)
+ {
+ float scale_factor = new_dpi_scale / viewport->DpiScale;
+ if (g.IO.ConfigFlags & ImGuiConfigFlags_DpiEnableScaleViewports)
+ ScaleWindowsInViewport(viewport, scale_factor);
+ //if (viewport == GetMainViewport())
+ // g.PlatformInterface.SetWindowSize(viewport, viewport->Size * scale_factor);
+
+ // Scale our window moving pivot so that the window will rescale roughly around the mouse position.
+ // FIXME-VIEWPORT: This currently creates a resizing feedback loop when a window is straddling a DPI transition border.
+ // (Minor: since our sizes do not perfectly linearly scale, deferring the click offset scale until we know the actual window scale ratio may get us slightly more precise mouse positioning.)
+ //if (g.MovingWindow != NULL && g.MovingWindow->Viewport == viewport)
+ // g.ActiveIdClickOffset = ImTrunc(g.ActiveIdClickOffset * scale_factor);
+ }
+ viewport->DpiScale = new_dpi_scale;
+ }
+
+ // Update fallback monitor
+ g.PlatformMonitorsFullWorkRect = ImRect(+FLT_MAX, +FLT_MAX, -FLT_MAX, -FLT_MAX);
+ if (g.PlatformIO.Monitors.Size == 0)
+ {
+ ImGuiPlatformMonitor* monitor = &g.FallbackMonitor;
+ monitor->MainPos = main_viewport->Pos;
+ monitor->MainSize = main_viewport->Size;
+ monitor->WorkPos = main_viewport->WorkPos;
+ monitor->WorkSize = main_viewport->WorkSize;
+ monitor->DpiScale = main_viewport->DpiScale;
+ g.PlatformMonitorsFullWorkRect.Add(monitor->WorkPos);
+ g.PlatformMonitorsFullWorkRect.Add(monitor->WorkPos + monitor->WorkSize);
+ }
+ else
+ {
+ g.FallbackMonitor = g.PlatformIO.Monitors[0];
+ }
+ for (ImGuiPlatformMonitor& monitor : g.PlatformIO.Monitors)
+ {
+ g.PlatformMonitorsFullWorkRect.Add(monitor.WorkPos);
+ g.PlatformMonitorsFullWorkRect.Add(monitor.WorkPos + monitor.WorkSize);
+ }
+
+ if (!viewports_enabled)
+ {
+ g.MouseViewport = main_viewport;
+ return;
+ }
+
+ // Mouse handling: decide on the actual mouse viewport for this frame between the active/focused viewport and the hovered viewport.
+ // Note that 'viewport_hovered' should skip over any viewport that has the ImGuiViewportFlags_NoInputs flags set.
+ ImGuiViewportP* viewport_hovered = NULL;
+ if (g.IO.BackendFlags & ImGuiBackendFlags_HasMouseHoveredViewport)
+ {
+ viewport_hovered = g.IO.MouseHoveredViewport ? (ImGuiViewportP*)FindViewportByID(g.IO.MouseHoveredViewport) : NULL;
+ if (viewport_hovered && (viewport_hovered->Flags & ImGuiViewportFlags_NoInputs))
+ viewport_hovered = FindHoveredViewportFromPlatformWindowStack(g.IO.MousePos); // Backend failed to handle _NoInputs viewport: revert to our fallback.
+ }
+ else
+ {
+ // If the backend doesn't know how to honor ImGuiViewportFlags_NoInputs, we do a search ourselves. Note that this search:
+ // A) won't take account of the possibility that non-imgui windows may be in-between our dragged window and our target window.
+ // B) won't take account of how the backend apply parent<>child relationship to secondary viewports, which affects their Z order.
+ // C) uses LastFrameAsRefViewport as a flawed replacement for the last time a window was focused (we could/should fix that by introducing Focus functions in PlatformIO)
+ viewport_hovered = FindHoveredViewportFromPlatformWindowStack(g.IO.MousePos);
+ }
+ if (viewport_hovered != NULL)
+ g.MouseLastHoveredViewport = viewport_hovered;
+ else if (g.MouseLastHoveredViewport == NULL)
+ g.MouseLastHoveredViewport = g.Viewports[0];
+
+ // Update mouse reference viewport
+ // (when moving a window we aim at its viewport, but this will be overwritten below if we go in drag and drop mode)
+ // (MovingViewport->Viewport will be NULL in the rare situation where the window disappared while moving, set UpdateMouseMovingWindowNewFrame() for details)
+ if (g.MovingWindow && g.MovingWindow->Viewport)
+ g.MouseViewport = g.MovingWindow->Viewport;
+ else
+ g.MouseViewport = g.MouseLastHoveredViewport;
+
+ // When dragging something, always refer to the last hovered viewport.
+ // - when releasing a moving window we will revert to aiming behind (at viewport_hovered)
+ // - when we are between viewports, our dragged preview will tend to show in the last viewport _even_ if we don't have tooltips in their viewports (when lacking monitor info)
+ // - consider the case of holding on a menu item to browse child menus: even thou a mouse button is held, there's no active id because menu items only react on mouse release.
+ // FIXME-VIEWPORT: This is essentially broken, when ImGuiBackendFlags_HasMouseHoveredViewport is set we want to trust when viewport_hovered==NULL and use that.
+ const bool is_mouse_dragging_with_an_expected_destination = g.DragDropActive;
+ if (is_mouse_dragging_with_an_expected_destination && viewport_hovered == NULL)
+ viewport_hovered = g.MouseLastHoveredViewport;
+ if (is_mouse_dragging_with_an_expected_destination || g.ActiveId == 0 || !IsAnyMouseDown())
+ if (viewport_hovered != NULL && viewport_hovered != g.MouseViewport && !(viewport_hovered->Flags & ImGuiViewportFlags_NoInputs))
+ g.MouseViewport = viewport_hovered;
+
+ IM_ASSERT(g.MouseViewport != NULL);
+}
+
+// Update user-facing viewport list (g.Viewports -> g.PlatformIO.Viewports after filtering out some)
+static void ImGui::UpdateViewportsEndFrame()
+{
+ ImGuiContext& g = *GImGui;
+ g.PlatformIO.Viewports.resize(0);
+ for (int i = 0; i < g.Viewports.Size; i++)
+ {
+ ImGuiViewportP* viewport = g.Viewports[i];
+ viewport->LastPos = viewport->Pos;
+ if (viewport->LastFrameActive < g.FrameCount || viewport->Size.x <= 0.0f || viewport->Size.y <= 0.0f)
+ if (i > 0) // Always include main viewport in the list
+ continue;
+ if (viewport->Window && !IsWindowActiveAndVisible(viewport->Window))
+ continue;
+ if (i > 0)
+ IM_ASSERT(viewport->Window != NULL);
+ g.PlatformIO.Viewports.push_back(viewport);
+ }
+ g.Viewports[0]->ClearRequestFlags(); // Clear main viewport flags because UpdatePlatformWindows() won't do it and may not even be called
+}
+
+// FIXME: We should ideally refactor the system to call this every frame (we currently don't)
+ImGuiViewportP* ImGui::AddUpdateViewport(ImGuiWindow* window, ImGuiID id, const ImVec2& pos, const ImVec2& size, ImGuiViewportFlags flags)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(id != 0);
+
+ flags |= ImGuiViewportFlags_IsPlatformWindow;
+ if (window != NULL)
+ {
+ if (g.MovingWindow && g.MovingWindow->RootWindowDockTree == window)
+ flags |= ImGuiViewportFlags_NoInputs | ImGuiViewportFlags_NoFocusOnAppearing;
+ if ((window->Flags & ImGuiWindowFlags_NoMouseInputs) && (window->Flags & ImGuiWindowFlags_NoNavInputs))
+ flags |= ImGuiViewportFlags_NoInputs;
+ if (window->Flags & ImGuiWindowFlags_NoFocusOnAppearing)
+ flags |= ImGuiViewportFlags_NoFocusOnAppearing;
+ }
+
+ ImGuiViewportP* viewport = (ImGuiViewportP*)FindViewportByID(id);
+ if (viewport)
+ {
+ // Always update for main viewport as we are already pulling correct platform pos/size (see #4900)
+ if (!viewport->PlatformRequestMove || viewport->ID == IMGUI_VIEWPORT_DEFAULT_ID)
+ viewport->Pos = pos;
+ if (!viewport->PlatformRequestResize || viewport->ID == IMGUI_VIEWPORT_DEFAULT_ID)
+ viewport->Size = size;
+ viewport->Flags = flags | (viewport->Flags & (ImGuiViewportFlags_IsMinimized | ImGuiViewportFlags_IsFocused)); // Preserve existing flags
+ }
+ else
+ {
+ // New viewport
+ viewport = IM_NEW(ImGuiViewportP)();
+ viewport->ID = id;
+ viewport->Idx = g.Viewports.Size;
+ viewport->Pos = viewport->LastPos = pos;
+ viewport->Size = size;
+ viewport->Flags = flags;
+ UpdateViewportPlatformMonitor(viewport);
+ g.Viewports.push_back(viewport);
+ g.ViewportCreatedCount++;
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Add Viewport %08X '%s'\n", id, window ? window->Name : "<NULL>");
+
+ // We normally setup for all viewports in NewFrame() but here need to handle the mid-frame creation of a new viewport.
+ // We need to extend the fullscreen clip rect so the OverlayDrawList clip is correct for that the first frame
+ g.DrawListSharedData.ClipRectFullscreen.x = ImMin(g.DrawListSharedData.ClipRectFullscreen.x, viewport->Pos.x);
+ g.DrawListSharedData.ClipRectFullscreen.y = ImMin(g.DrawListSharedData.ClipRectFullscreen.y, viewport->Pos.y);
+ g.DrawListSharedData.ClipRectFullscreen.z = ImMax(g.DrawListSharedData.ClipRectFullscreen.z, viewport->Pos.x + viewport->Size.x);
+ g.DrawListSharedData.ClipRectFullscreen.w = ImMax(g.DrawListSharedData.ClipRectFullscreen.w, viewport->Pos.y + viewport->Size.y);
+
+ // Store initial DpiScale before the OS platform window creation, based on expected monitor data.
+ // This is so we can select an appropriate font size on the first frame of our window lifetime
+ if (viewport->PlatformMonitor != -1)
+ viewport->DpiScale = g.PlatformIO.Monitors[viewport->PlatformMonitor].DpiScale;
+ }
+
+ viewport->Window = window;
+ viewport->LastFrameActive = g.FrameCount;
+ viewport->UpdateWorkRect();
+ IM_ASSERT(window == NULL || viewport->ID == window->ID);
+
+ if (window != NULL)
+ window->ViewportOwned = true;
+
+ return viewport;
+}
+
+static void ImGui::DestroyViewport(ImGuiViewportP* viewport)
+{
+ // Clear references to this viewport in windows (window->ViewportId becomes the master data)
+ ImGuiContext& g = *GImGui;
+ for (ImGuiWindow* window : g.Windows)
+ {
+ if (window->Viewport != viewport)
+ continue;
+ window->Viewport = NULL;
+ window->ViewportOwned = false;
+ }
+ if (viewport == g.MouseLastHoveredViewport)
+ g.MouseLastHoveredViewport = NULL;
+
+ // Destroy
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Delete Viewport %08X '%s'\n", viewport->ID, viewport->Window ? viewport->Window->Name : "n/a");
+ DestroyPlatformWindow(viewport); // In most circumstances the platform window will already be destroyed here.
+ IM_ASSERT(g.PlatformIO.Viewports.contains(viewport) == false);
+ IM_ASSERT(g.Viewports[viewport->Idx] == viewport);
+ g.Viewports.erase(g.Viewports.Data + viewport->Idx);
+ IM_DELETE(viewport);
+}
+
+// FIXME-VIEWPORT: This is all super messy and ought to be clarified or rewritten.
+static void ImGui::WindowSelectViewport(ImGuiWindow* window)
+{
+ ImGuiContext& g = *GImGui;
+ ImGuiWindowFlags flags = window->Flags;
+ window->ViewportAllowPlatformMonitorExtend = -1;
+
+ // Restore main viewport if multi-viewport is not supported by the backend
+ ImGuiViewportP* main_viewport = (ImGuiViewportP*)(void*)GetMainViewport();
+ if (!(g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable))
+ {
+ SetWindowViewport(window, main_viewport);
+ return;
+ }
+ window->ViewportOwned = false;
+
+ // Appearing popups reset their viewport so they can inherit again
+ if ((flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)) && window->Appearing)
+ {
+ window->Viewport = NULL;
+ window->ViewportId = 0;
+ }
+
+ if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasViewport) == 0)
+ {
+ // By default inherit from parent window
+ if (window->Viewport == NULL && window->ParentWindow && (!window->ParentWindow->IsFallbackWindow || window->ParentWindow->WasActive))
+ window->Viewport = window->ParentWindow->Viewport;
+
+ // Attempt to restore saved viewport id (= window that hasn't been activated yet), try to restore the viewport based on saved 'window->ViewportPos' restored from .ini file
+ if (window->Viewport == NULL && window->ViewportId != 0)
+ {
+ window->Viewport = (ImGuiViewportP*)FindViewportByID(window->ViewportId);
+ if (window->Viewport == NULL && window->ViewportPos.x != FLT_MAX && window->ViewportPos.y != FLT_MAX)
+ window->Viewport = AddUpdateViewport(window, window->ID, window->ViewportPos, window->Size, ImGuiViewportFlags_None);
+ }
+ }
+
+ bool lock_viewport = false;
+ if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasViewport)
+ {
+ // Code explicitly request a viewport
+ window->Viewport = (ImGuiViewportP*)FindViewportByID(g.NextWindowData.ViewportId);
+ window->ViewportId = g.NextWindowData.ViewportId; // Store ID even if Viewport isn't resolved yet.
+ if (window->Viewport && (window->Flags & ImGuiWindowFlags_DockNodeHost) != 0 && window->Viewport->Window != NULL)
+ {
+ window->Viewport->Window = window;
+ window->Viewport->ID = window->ViewportId = window->ID; // Overwrite ID (always owned by node)
+ }
+ lock_viewport = true;
+ }
+ else if ((flags & ImGuiWindowFlags_ChildWindow) || (flags & ImGuiWindowFlags_ChildMenu))
+ {
+ // Always inherit viewport from parent window
+ if (window->DockNode && window->DockNode->HostWindow)
+ IM_ASSERT(window->DockNode->HostWindow->Viewport == window->ParentWindow->Viewport);
+ window->Viewport = window->ParentWindow->Viewport;
+ }
+ else if (window->DockNode && window->DockNode->HostWindow)
+ {
+ // This covers the "always inherit viewport from parent window" case for when a window reattach to a node that was just created mid-frame
+ window->Viewport = window->DockNode->HostWindow->Viewport;
+ }
+ else if (flags & ImGuiWindowFlags_Tooltip)
+ {
+ window->Viewport = g.MouseViewport;
+ }
+ else if (GetWindowAlwaysWantOwnViewport(window))
+ {
+ window->Viewport = AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_None);
+ }
+ else if (g.MovingWindow && g.MovingWindow->RootWindowDockTree == window && IsMousePosValid())
+ {
+ if (window->Viewport != NULL && window->Viewport->Window == window)
+ window->Viewport = AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_None);
+ }
+ else
+ {
+ // Merge into host viewport?
+ // We cannot test window->ViewportOwned as it set lower in the function.
+ // Testing (g.ActiveId == 0 || g.ActiveIdAllowOverlap) to avoid merging during a short-term widget interaction. Main intent was to avoid during resize (see #4212)
+ bool try_to_merge_into_host_viewport = (window->Viewport && window == window->Viewport->Window && (g.ActiveId == 0 || g.ActiveIdAllowOverlap));
+ if (try_to_merge_into_host_viewport)
+ UpdateTryMergeWindowIntoHostViewports(window);
+ }
+
+ // Fallback: merge in default viewport if z-order matches, otherwise create a new viewport
+ if (window->Viewport == NULL)
+ if (!UpdateTryMergeWindowIntoHostViewport(window, main_viewport))
+ window->Viewport = AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_None);
+
+ // Mark window as allowed to protrude outside of its viewport and into the current monitor
+ if (!lock_viewport)
+ {
+ if (flags & (ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_Popup))
+ {
+ // We need to take account of the possibility that mouse may become invalid.
+ // Popups/Tooltip always set ViewportAllowPlatformMonitorExtend so GetWindowAllowedExtentRect() will return full monitor bounds.
+ ImVec2 mouse_ref = (flags & ImGuiWindowFlags_Tooltip) ? g.IO.MousePos : g.BeginPopupStack.back().OpenMousePos;
+ bool use_mouse_ref = (g.NavDisableHighlight || !g.NavDisableMouseHover || !g.NavWindow);
+ bool mouse_valid = IsMousePosValid(&mouse_ref);
+ if ((window->Appearing || (flags & (ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_ChildMenu))) && (!use_mouse_ref || mouse_valid))
+ window->ViewportAllowPlatformMonitorExtend = FindPlatformMonitorForPos((use_mouse_ref && mouse_valid) ? mouse_ref : NavCalcPreferredRefPos());
+ else
+ window->ViewportAllowPlatformMonitorExtend = window->Viewport->PlatformMonitor;
+ }
+ else if (window->Viewport && window != window->Viewport->Window && window->Viewport->Window && !(flags & ImGuiWindowFlags_ChildWindow) && window->DockNode == NULL)
+ {
+ // When called from Begin() we don't have access to a proper version of the Hidden flag yet, so we replicate this code.
+ const bool will_be_visible = (window->DockIsActive && !window->DockTabIsVisible) ? false : true;
+ if ((window->Flags & ImGuiWindowFlags_DockNodeHost) && window->Viewport->LastFrameActive < g.FrameCount && will_be_visible)
+ {
+ // Steal/transfer ownership
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Window '%s' steal Viewport %08X from Window '%s'\n", window->Name, window->Viewport->ID, window->Viewport->Window->Name);
+ window->Viewport->Window = window;
+ window->Viewport->ID = window->ID;
+ window->Viewport->LastNameHash = 0;
+ }
+ else if (!UpdateTryMergeWindowIntoHostViewports(window)) // Merge?
+ {
+ // New viewport
+ window->Viewport = AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_NoFocusOnAppearing);
+ }
+ }
+ else if (window->ViewportAllowPlatformMonitorExtend < 0 && (flags & ImGuiWindowFlags_ChildWindow) == 0)
+ {
+ // Regular (non-child, non-popup) windows by default are also allowed to protrude
+ // Child windows are kept contained within their parent.
+ window->ViewportAllowPlatformMonitorExtend = window->Viewport->PlatformMonitor;
+ }
+ }
+
+ // Update flags
+ window->ViewportOwned = (window == window->Viewport->Window);
+ window->ViewportId = window->Viewport->ID;
+
+ // If the OS window has a title bar, hide our imgui title bar
+ //if (window->ViewportOwned && !(window->Viewport->Flags & ImGuiViewportFlags_NoDecoration))
+ // window->Flags |= ImGuiWindowFlags_NoTitleBar;
+}
+
+void ImGui::WindowSyncOwnedViewport(ImGuiWindow* window, ImGuiWindow* parent_window_in_stack)
+{
+ ImGuiContext& g = *GImGui;
+
+ bool viewport_rect_changed = false;
+
+ // Synchronize window --> viewport in most situations
+ // Synchronize viewport -> window in case the platform window has been moved or resized from the OS/WM
+ if (window->Viewport->PlatformRequestMove)
+ {
+ window->Pos = window->Viewport->Pos;
+ MarkIniSettingsDirty(window);
+ }
+ else if (memcmp(&window->Viewport->Pos, &window->Pos, sizeof(window->Pos)) != 0)
+ {
+ viewport_rect_changed = true;
+ window->Viewport->Pos = window->Pos;
+ }
+
+ if (window->Viewport->PlatformRequestResize)
+ {
+ window->Size = window->SizeFull = window->Viewport->Size;
+ MarkIniSettingsDirty(window);
+ }
+ else if (memcmp(&window->Viewport->Size, &window->Size, sizeof(window->Size)) != 0)
+ {
+ viewport_rect_changed = true;
+ window->Viewport->Size = window->Size;
+ }
+ window->Viewport->UpdateWorkRect();
+
+ // The viewport may have changed monitor since the global update in UpdateViewportsNewFrame()
+ // Either a SetNextWindowPos() call in the current frame or a SetWindowPos() call in the previous frame may have this effect.
+ if (viewport_rect_changed)
+ UpdateViewportPlatformMonitor(window->Viewport);
+
+ // Update common viewport flags
+ const ImGuiViewportFlags viewport_flags_to_clear = ImGuiViewportFlags_TopMost | ImGuiViewportFlags_NoTaskBarIcon | ImGuiViewportFlags_NoDecoration | ImGuiViewportFlags_NoRendererClear;
+ ImGuiViewportFlags viewport_flags = window->Viewport->Flags & ~viewport_flags_to_clear;
+ ImGuiWindowFlags window_flags = window->Flags;
+ const bool is_modal = (window_flags & ImGuiWindowFlags_Modal) != 0;
+ const bool is_short_lived_floating_window = (window_flags & (ImGuiWindowFlags_ChildMenu | ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_Popup)) != 0;
+ if (window_flags & ImGuiWindowFlags_Tooltip)
+ viewport_flags |= ImGuiViewportFlags_TopMost;
+ if ((g.IO.ConfigViewportsNoTaskBarIcon || is_short_lived_floating_window) && !is_modal)
+ viewport_flags |= ImGuiViewportFlags_NoTaskBarIcon;
+ if (g.IO.ConfigViewportsNoDecoration || is_short_lived_floating_window)
+ viewport_flags |= ImGuiViewportFlags_NoDecoration;
+
+ // Not correct to set modal as topmost because:
+ // - Because other popups can be stacked above a modal (e.g. combo box in a modal)
+ // - ImGuiViewportFlags_TopMost is currently handled different in backends: in Win32 it is "appear top most" whereas in GLFW and SDL it is "stay topmost"
+ //if (flags & ImGuiWindowFlags_Modal)
+ // viewport_flags |= ImGuiViewportFlags_TopMost;
+
+ // For popups and menus that may be protruding out of their parent viewport, we enable _NoFocusOnClick so that clicking on them
+ // won't steal the OS focus away from their parent window (which may be reflected in OS the title bar decoration).
+ // Setting _NoFocusOnClick would technically prevent us from bringing back to front in case they are being covered by an OS window from a different app,
+ // but it shouldn't be much of a problem considering those are already popups that are closed when clicking elsewhere.
+ if (is_short_lived_floating_window && !is_modal)
+ viewport_flags |= ImGuiViewportFlags_NoFocusOnAppearing | ImGuiViewportFlags_NoFocusOnClick;
+
+ // We can overwrite viewport flags using ImGuiWindowClass (advanced users)
+ if (window->WindowClass.ViewportFlagsOverrideSet)
+ viewport_flags |= window->WindowClass.ViewportFlagsOverrideSet;
+ if (window->WindowClass.ViewportFlagsOverrideClear)
+ viewport_flags &= ~window->WindowClass.ViewportFlagsOverrideClear;
+
+ // We can also tell the backend that clearing the platform window won't be necessary,
+ // as our window background is filling the viewport and we have disabled BgAlpha.
+ // FIXME: Work on support for per-viewport transparency (#2766)
+ if (!(window_flags & ImGuiWindowFlags_NoBackground))
+ viewport_flags |= ImGuiViewportFlags_NoRendererClear;
+
+ window->Viewport->Flags = viewport_flags;
+
+ // Update parent viewport ID
+ // (the !IsFallbackWindow test mimic the one done in WindowSelectViewport())
+ if (window->WindowClass.ParentViewportId != (ImGuiID)-1)
+ window->Viewport->ParentViewportId = window->WindowClass.ParentViewportId;
+ else if ((window_flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)) && parent_window_in_stack && (!parent_window_in_stack->IsFallbackWindow || parent_window_in_stack->WasActive))
+ window->Viewport->ParentViewportId = parent_window_in_stack->Viewport->ID;
+ else
+ window->Viewport->ParentViewportId = g.IO.ConfigViewportsNoDefaultParent ? 0 : IMGUI_VIEWPORT_DEFAULT_ID;
+}
+
+// Called by user at the end of the main loop, after EndFrame()
+// This will handle the creation/update of all OS windows via function defined in the ImGuiPlatformIO api.
+void ImGui::UpdatePlatformWindows()
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(g.FrameCountEnded == g.FrameCount && "Forgot to call Render() or EndFrame() before UpdatePlatformWindows()?");
+ IM_ASSERT(g.FrameCountPlatformEnded < g.FrameCount);
+ g.FrameCountPlatformEnded = g.FrameCount;
+ if (!(g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable))
+ return;
+
+ // Create/resize/destroy platform windows to match each active viewport.
+ // Skip the main viewport (index 0), which is always fully handled by the application!
+ for (int i = 1; i < g.Viewports.Size; i++)
+ {
+ ImGuiViewportP* viewport = g.Viewports[i];
+
+ // Destroy platform window if the viewport hasn't been submitted or if it is hosting a hidden window
+ // (the implicit/fallback Debug##Default window will be registering its viewport then be disabled, causing a dummy DestroyPlatformWindow to be made each frame)
+ bool destroy_platform_window = false;
+ destroy_platform_window |= (viewport->LastFrameActive < g.FrameCount - 1);
+ destroy_platform_window |= (viewport->Window && !IsWindowActiveAndVisible(viewport->Window));
+ if (destroy_platform_window)
+ {
+ DestroyPlatformWindow(viewport);
+ continue;
+ }
+
+ // New windows that appears directly in a new viewport won't always have a size on their first frame
+ if (viewport->LastFrameActive < g.FrameCount || viewport->Size.x <= 0 || viewport->Size.y <= 0)
+ continue;
+
+ // Create window
+ const bool is_new_platform_window = (viewport->PlatformWindowCreated == false);
+ if (is_new_platform_window)
+ {
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Create Platform Window %08X '%s'\n", viewport->ID, viewport->Window ? viewport->Window->Name : "n/a");
+ g.PlatformIO.Platform_CreateWindow(viewport);
+ if (g.PlatformIO.Renderer_CreateWindow != NULL)
+ g.PlatformIO.Renderer_CreateWindow(viewport);
+ g.PlatformWindowsCreatedCount++;
+ viewport->LastNameHash = 0;
+ viewport->LastPlatformPos = viewport->LastPlatformSize = ImVec2(FLT_MAX, FLT_MAX); // By clearing those we'll enforce a call to Platform_SetWindowPos/Size below, before Platform_ShowWindow (FIXME: Is that necessary?)
+ viewport->LastRendererSize = viewport->Size; // We don't need to call Renderer_SetWindowSize() as it is expected Renderer_CreateWindow() already did it.
+ viewport->PlatformWindowCreated = true;
+ }
+
+ // Apply Position and Size (from ImGui to Platform/Renderer backends)
+ if ((viewport->LastPlatformPos.x != viewport->Pos.x || viewport->LastPlatformPos.y != viewport->Pos.y) && !viewport->PlatformRequestMove)
+ g.PlatformIO.Platform_SetWindowPos(viewport, viewport->Pos);
+ if ((viewport->LastPlatformSize.x != viewport->Size.x || viewport->LastPlatformSize.y != viewport->Size.y) && !viewport->PlatformRequestResize)
+ g.PlatformIO.Platform_SetWindowSize(viewport, viewport->Size);
+ if ((viewport->LastRendererSize.x != viewport->Size.x || viewport->LastRendererSize.y != viewport->Size.y) && g.PlatformIO.Renderer_SetWindowSize)
+ g.PlatformIO.Renderer_SetWindowSize(viewport, viewport->Size);
+ viewport->LastPlatformPos = viewport->Pos;
+ viewport->LastPlatformSize = viewport->LastRendererSize = viewport->Size;
+
+ // Update title bar (if it changed)
+ if (ImGuiWindow* window_for_title = GetWindowForTitleDisplay(viewport->Window))
+ {
+ const char* title_begin = window_for_title->Name;
+ char* title_end = (char*)(intptr_t)FindRenderedTextEnd(title_begin);
+ const ImGuiID title_hash = ImHashStr(title_begin, title_end - title_begin);
+ if (viewport->LastNameHash != title_hash)
+ {
+ char title_end_backup_c = *title_end;
+ *title_end = 0; // Cut existing buffer short instead of doing an alloc/free, no small gain.
+ g.PlatformIO.Platform_SetWindowTitle(viewport, title_begin);
+ *title_end = title_end_backup_c;
+ viewport->LastNameHash = title_hash;
+ }
+ }
+
+ // Update alpha (if it changed)
+ if (viewport->LastAlpha != viewport->Alpha && g.PlatformIO.Platform_SetWindowAlpha)
+ g.PlatformIO.Platform_SetWindowAlpha(viewport, viewport->Alpha);
+ viewport->LastAlpha = viewport->Alpha;
+
+ // Optional, general purpose call to allow the backend to perform general book-keeping even if things haven't changed.
+ if (g.PlatformIO.Platform_UpdateWindow)
+ g.PlatformIO.Platform_UpdateWindow(viewport);
+
+ if (is_new_platform_window)
+ {
+ // On startup ensure new platform window don't steal focus (give it a few frames, as nested contents may lead to viewport being created a few frames late)
+ if (g.FrameCount < 3)
+ viewport->Flags |= ImGuiViewportFlags_NoFocusOnAppearing;
+
+ // Show window
+ g.PlatformIO.Platform_ShowWindow(viewport);
+
+ // Even without focus, we assume the window becomes front-most.
+ // This is useful for our platform z-order heuristic when io.MouseHoveredViewport is not available.
+ if (viewport->LastFocusedStampCount != g.ViewportFocusedStampCount)
+ viewport->LastFocusedStampCount = ++g.ViewportFocusedStampCount;
+ }
+
+ // Clear request flags
+ viewport->ClearRequestFlags();
}
}
+// This is a default/basic function for performing the rendering/swap of multiple Platform Windows.
+// Custom renderers may prefer to not call this function at all, and instead iterate the publicly exposed platform data and handle rendering/sync themselves.
+// The Render/Swap functions stored in ImGuiPlatformIO are merely here to allow for this helper to exist, but you can do it yourself:
+//
+// ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+// for (int i = 1; i < platform_io.Viewports.Size; i++)
+// if ((platform_io.Viewports[i]->Flags & ImGuiViewportFlags_Minimized) == 0)
+// MyRenderFunction(platform_io.Viewports[i], my_args);
+// for (int i = 1; i < platform_io.Viewports.Size; i++)
+// if ((platform_io.Viewports[i]->Flags & ImGuiViewportFlags_Minimized) == 0)
+// MySwapBufferFunction(platform_io.Viewports[i], my_args);
+//
+void ImGui::RenderPlatformWindowsDefault(void* platform_render_arg, void* renderer_render_arg)
+{
+ // Skip the main viewport (index 0), which is always fully handled by the application!
+ ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+ for (int i = 1; i < platform_io.Viewports.Size; i++)
+ {
+ ImGuiViewport* viewport = platform_io.Viewports[i];
+ if (viewport->Flags & ImGuiViewportFlags_IsMinimized)
+ continue;
+ if (platform_io.Platform_RenderWindow) platform_io.Platform_RenderWindow(viewport, platform_render_arg);
+ if (platform_io.Renderer_RenderWindow) platform_io.Renderer_RenderWindow(viewport, renderer_render_arg);
+ }
+ for (int i = 1; i < platform_io.Viewports.Size; i++)
+ {
+ ImGuiViewport* viewport = platform_io.Viewports[i];
+ if (viewport->Flags & ImGuiViewportFlags_IsMinimized)
+ continue;
+ if (platform_io.Platform_SwapBuffers) platform_io.Platform_SwapBuffers(viewport, platform_render_arg);
+ if (platform_io.Renderer_SwapBuffers) platform_io.Renderer_SwapBuffers(viewport, renderer_render_arg);
+ }
+}
+
+static int ImGui::FindPlatformMonitorForPos(const ImVec2& pos)
+{
+ ImGuiContext& g = *GImGui;
+ for (int monitor_n = 0; monitor_n < g.PlatformIO.Monitors.Size; monitor_n++)
+ {
+ const ImGuiPlatformMonitor& monitor = g.PlatformIO.Monitors[monitor_n];
+ if (ImRect(monitor.MainPos, monitor.MainPos + monitor.MainSize).Contains(pos))
+ return monitor_n;
+ }
+ return -1;
+}
+
+// Search for the monitor with the largest intersection area with the given rectangle
+// We generally try to avoid searching loops but the monitor count should be very small here
+// FIXME-OPT: We could test the last monitor used for that viewport first, and early
+static int ImGui::FindPlatformMonitorForRect(const ImRect& rect)
+{
+ ImGuiContext& g = *GImGui;
+
+ const int monitor_count = g.PlatformIO.Monitors.Size;
+ if (monitor_count <= 1)
+ return monitor_count - 1;
+
+ // Use a minimum threshold of 1.0f so a zero-sized rect won't false positive, and will still find the correct monitor given its position.
+ // This is necessary for tooltips which always resize down to zero at first.
+ const float surface_threshold = ImMax(rect.GetWidth() * rect.GetHeight() * 0.5f, 1.0f);
+ int best_monitor_n = -1;
+ float best_monitor_surface = 0.001f;
+
+ for (int monitor_n = 0; monitor_n < g.PlatformIO.Monitors.Size && best_monitor_surface < surface_threshold; monitor_n++)
+ {
+ const ImGuiPlatformMonitor& monitor = g.PlatformIO.Monitors[monitor_n];
+ const ImRect monitor_rect = ImRect(monitor.MainPos, monitor.MainPos + monitor.MainSize);
+ if (monitor_rect.Contains(rect))
+ return monitor_n;
+ ImRect overlapping_rect = rect;
+ overlapping_rect.ClipWithFull(monitor_rect);
+ float overlapping_surface = overlapping_rect.GetWidth() * overlapping_rect.GetHeight();
+ if (overlapping_surface < best_monitor_surface)
+ continue;
+ best_monitor_surface = overlapping_surface;
+ best_monitor_n = monitor_n;
+ }
+ return best_monitor_n;
+}
+
+// Update monitor from viewport rectangle (we'll use this info to clamp windows and save windows lost in a removed monitor)
+static void ImGui::UpdateViewportPlatformMonitor(ImGuiViewportP* viewport)
+{
+ viewport->PlatformMonitor = (short)FindPlatformMonitorForRect(viewport->GetMainRect());
+}
+
+// Return value is always != NULL, but don't hold on it across frames.
+const ImGuiPlatformMonitor* ImGui::GetViewportPlatformMonitor(ImGuiViewport* viewport_p)
+{
+ ImGuiContext& g = *GImGui;
+ ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)viewport_p;
+ int monitor_idx = viewport->PlatformMonitor;
+ if (monitor_idx >= 0 && monitor_idx < g.PlatformIO.Monitors.Size)
+ return &g.PlatformIO.Monitors[monitor_idx];
+ return &g.FallbackMonitor;
+}
+
+void ImGui::DestroyPlatformWindow(ImGuiViewportP* viewport)
+{
+ ImGuiContext& g = *GImGui;
+ if (viewport->PlatformWindowCreated)
+ {
+ IMGUI_DEBUG_LOG_VIEWPORT("[viewport] Destroy Platform Window %08X '%s'\n", viewport->ID, viewport->Window ? viewport->Window->Name : "n/a");
+ if (g.PlatformIO.Renderer_DestroyWindow)
+ g.PlatformIO.Renderer_DestroyWindow(viewport);
+ if (g.PlatformIO.Platform_DestroyWindow)
+ g.PlatformIO.Platform_DestroyWindow(viewport);
+ IM_ASSERT(viewport->RendererUserData == NULL && viewport->PlatformUserData == NULL);
+
+ // Don't clear PlatformWindowCreated for the main viewport, as we initially set that up to true in Initialize()
+ // The righter way may be to leave it to the backend to set this flag all-together, and made the flag public.
+ if (viewport->ID != IMGUI_VIEWPORT_DEFAULT_ID)
+ viewport->PlatformWindowCreated = false;
+ }
+ else
+ {
+ IM_ASSERT(viewport->RendererUserData == NULL && viewport->PlatformUserData == NULL && viewport->PlatformHandle == NULL);
+ }
+ viewport->RendererUserData = viewport->PlatformUserData = viewport->PlatformHandle = NULL;
+ viewport->ClearRequestFlags();
+}
+
+void ImGui::DestroyPlatformWindows()
+{
+ // We call the destroy window on every viewport (including the main viewport, index 0) to give a chance to the backend
+ // to clear any data they may have stored in e.g. PlatformUserData, RendererUserData.
+ // It is convenient for the platform backend code to store something in the main viewport, in order for e.g. the mouse handling
+ // code to operator a consistent manner.
+ // It is expected that the backend can handle calls to Renderer_DestroyWindow/Platform_DestroyWindow without
+ // crashing if it doesn't have data stored.
+ ImGuiContext& g = *GImGui;
+ for (ImGuiViewportP* viewport : g.Viewports)
+ DestroyPlatformWindow(viewport);
+}
+
+
//-----------------------------------------------------------------------------
// [SECTION] DOCKING
//-----------------------------------------------------------------------------
+// Docking: Internal Types
+// Docking: Forward Declarations
+// Docking: ImGuiDockContext
+// Docking: ImGuiDockContext Docking/Undocking functions
+// Docking: ImGuiDockNode
+// Docking: ImGuiDockNode Tree manipulation functions
+// Docking: Public Functions (SetWindowDock, DockSpace, DockSpaceOverViewport)
+// Docking: Builder Functions
+// Docking: Begin/End Support Functions (called from Begin/End)
+// Docking: Settings
+//-----------------------------------------------------------------------------
-// (this section is filled in the 'docking' branch)
+//-----------------------------------------------------------------------------
+// Typical Docking call flow: (root level is generally public API):
+//-----------------------------------------------------------------------------
+// - NewFrame() new dear imgui frame
+// | DockContextNewFrameUpdateUndocking() - process queued undocking requests
+// | - DockContextProcessUndockWindow() - process one window undocking request
+// | - DockContextProcessUndockNode() - process one whole node undocking request
+// | DockContextNewFrameUpdateUndocking() - process queue docking requests, create floating dock nodes
+// | - update g.HoveredDockNode - [debug] update node hovered by mouse
+// | - DockContextProcessDock() - process one docking request
+// | - DockNodeUpdate()
+// | - DockNodeUpdateForRootNode()
+// | - DockNodeUpdateFlagsAndCollapse()
+// | - DockNodeFindInfo()
+// | - destroy unused node or tab bar
+// | - create dock node host window
+// | - Begin() etc.
+// | - DockNodeStartMouseMovingWindow()
+// | - DockNodeTreeUpdatePosSize()
+// | - DockNodeTreeUpdateSplitter()
+// | - draw node background
+// | - DockNodeUpdateTabBar() - create/update tab bar for a docking node
+// | - DockNodeAddTabBar()
+// | - DockNodeWindowMenuUpdate()
+// | - DockNodeCalcTabBarLayout()
+// | - BeginTabBarEx()
+// | - TabItemEx() calls
+// | - EndTabBar()
+// | - BeginDockableDragDropTarget()
+// | - DockNodeUpdate() - recurse into child nodes...
+//-----------------------------------------------------------------------------
+// - DockSpace() user submit a dockspace into a window
+// | Begin(Child) - create a child window
+// | DockNodeUpdate() - call main dock node update function
+// | End(Child)
+// | ItemSize()
+//-----------------------------------------------------------------------------
+// - Begin()
+// | BeginDocked()
+// | BeginDockableDragDropSource()
+// | BeginDockableDragDropTarget()
+// | - DockNodePreviewDockRender()
+//-----------------------------------------------------------------------------
+// - EndFrame()
+// | DockContextEndFrame()
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Docking: Internal Types
+//-----------------------------------------------------------------------------
+// - ImGuiDockRequestType
+// - ImGuiDockRequest
+// - ImGuiDockPreviewData
+// - ImGuiDockNodeSettings
+// - ImGuiDockContext
+//-----------------------------------------------------------------------------
+
+enum ImGuiDockRequestType
+{
+ ImGuiDockRequestType_None = 0,
+ ImGuiDockRequestType_Dock,
+ ImGuiDockRequestType_Undock,
+ ImGuiDockRequestType_Split // Split is the same as Dock but without a DockPayload
+};
+
+struct ImGuiDockRequest
+{
+ ImGuiDockRequestType Type;
+ ImGuiWindow* DockTargetWindow; // Destination/Target Window to dock into (may be a loose window or a DockNode, might be NULL in which case DockTargetNode cannot be NULL)
+ ImGuiDockNode* DockTargetNode; // Destination/Target Node to dock into
+ ImGuiWindow* DockPayload; // Source/Payload window to dock (may be a loose window or a DockNode), [Optional]
+ ImGuiDir DockSplitDir;
+ float DockSplitRatio;
+ bool DockSplitOuter;
+ ImGuiWindow* UndockTargetWindow;
+ ImGuiDockNode* UndockTargetNode;
+
+ ImGuiDockRequest()
+ {
+ Type = ImGuiDockRequestType_None;
+ DockTargetWindow = DockPayload = UndockTargetWindow = NULL;
+ DockTargetNode = UndockTargetNode = NULL;
+ DockSplitDir = ImGuiDir_None;
+ DockSplitRatio = 0.5f;
+ DockSplitOuter = false;
+ }
+};
+
+struct ImGuiDockPreviewData
+{
+ ImGuiDockNode FutureNode;
+ bool IsDropAllowed;
+ bool IsCenterAvailable;
+ bool IsSidesAvailable; // Hold your breath, grammar freaks..
+ bool IsSplitDirExplicit; // Set when hovered the drop rect (vs. implicit SplitDir==None when hovered the window)
+ ImGuiDockNode* SplitNode;
+ ImGuiDir SplitDir;
+ float SplitRatio;
+ ImRect DropRectsDraw[ImGuiDir_COUNT + 1]; // May be slightly different from hit-testing drop rects used in DockNodeCalcDropRects()
+
+ ImGuiDockPreviewData() : FutureNode(0) { IsDropAllowed = IsCenterAvailable = IsSidesAvailable = IsSplitDirExplicit = false; SplitNode = NULL; SplitDir = ImGuiDir_None; SplitRatio = 0.f; for (int n = 0; n < IM_ARRAYSIZE(DropRectsDraw); n++) DropRectsDraw[n] = ImRect(+FLT_MAX, +FLT_MAX, -FLT_MAX, -FLT_MAX); }
+};
+
+// Persistent Settings data, stored contiguously in SettingsNodes (sizeof() ~32 bytes)
+struct ImGuiDockNodeSettings
+{
+ ImGuiID ID;
+ ImGuiID ParentNodeId;
+ ImGuiID ParentWindowId;
+ ImGuiID SelectedTabId;
+ signed char SplitAxis;
+ char Depth;
+ ImGuiDockNodeFlags Flags; // NB: We save individual flags one by one in ascii format (ImGuiDockNodeFlags_SavedFlagsMask_)
+ ImVec2ih Pos;
+ ImVec2ih Size;
+ ImVec2ih SizeRef;
+ ImGuiDockNodeSettings() { memset(this, 0, sizeof(*this)); SplitAxis = ImGuiAxis_None; }
+};
+
+//-----------------------------------------------------------------------------
+// Docking: Forward Declarations
+//-----------------------------------------------------------------------------
+
+namespace ImGui
+{
+ // ImGuiDockContext
+ static ImGuiDockNode* DockContextAddNode(ImGuiContext* ctx, ImGuiID id);
+ static void DockContextRemoveNode(ImGuiContext* ctx, ImGuiDockNode* node, bool merge_sibling_into_parent_node);
+ static void DockContextQueueNotifyRemovedNode(ImGuiContext* ctx, ImGuiDockNode* node);
+ static void DockContextProcessDock(ImGuiContext* ctx, ImGuiDockRequest* req);
+ static void DockContextPruneUnusedSettingsNodes(ImGuiContext* ctx);
+ static ImGuiDockNode* DockContextBindNodeToWindow(ImGuiContext* ctx, ImGuiWindow* window);
+ static void DockContextBuildNodesFromSettings(ImGuiContext* ctx, ImGuiDockNodeSettings* node_settings_array, int node_settings_count);
+ static void DockContextBuildAddWindowsToNodes(ImGuiContext* ctx, ImGuiID root_id); // Use root_id==0 to add all
+
+ // ImGuiDockNode
+ static void DockNodeAddWindow(ImGuiDockNode* node, ImGuiWindow* window, bool add_to_tab_bar);
+ static void DockNodeMoveWindows(ImGuiDockNode* dst_node, ImGuiDockNode* src_node);
+ static void DockNodeMoveChildNodes(ImGuiDockNode* dst_node, ImGuiDockNode* src_node);
+ static ImGuiWindow* DockNodeFindWindowByID(ImGuiDockNode* node, ImGuiID id);
+ static void DockNodeApplyPosSizeToWindows(ImGuiDockNode* node);
+ static void DockNodeRemoveWindow(ImGuiDockNode* node, ImGuiWindow* window, ImGuiID save_dock_id);
+ static void DockNodeHideHostWindow(ImGuiDockNode* node);
+ static void DockNodeUpdate(ImGuiDockNode* node);
+ static void DockNodeUpdateForRootNode(ImGuiDockNode* node);
+ static void DockNodeUpdateFlagsAndCollapse(ImGuiDockNode* node);
+ static void DockNodeUpdateHasCentralNodeChild(ImGuiDockNode* node);
+ static void DockNodeUpdateTabBar(ImGuiDockNode* node, ImGuiWindow* host_window);
+ static void DockNodeAddTabBar(ImGuiDockNode* node);
+ static void DockNodeRemoveTabBar(ImGuiDockNode* node);
+ static void DockNodeWindowMenuUpdate(ImGuiDockNode* node, ImGuiTabBar* tab_bar);
+ static void DockNodeUpdateVisibleFlag(ImGuiDockNode* node);
+ static void DockNodeStartMouseMovingWindow(ImGuiDockNode* node, ImGuiWindow* window);
+ static bool DockNodeIsDropAllowed(ImGuiWindow* host_window, ImGuiWindow* payload_window);
+ static void DockNodePreviewDockSetup(ImGuiWindow* host_window, ImGuiDockNode* host_node, ImGuiWindow* payload_window, ImGuiDockNode* payload_node, ImGuiDockPreviewData* preview_data, bool is_explicit_target, bool is_outer_docking);
+ static void DockNodePreviewDockRender(ImGuiWindow* host_window, ImGuiDockNode* host_node, ImGuiWindow* payload_window, const ImGuiDockPreviewData* preview_data);
+ static void DockNodeCalcTabBarLayout(const ImGuiDockNode* node, ImRect* out_title_rect, ImRect* out_tab_bar_rect, ImVec2* out_window_menu_button_pos, ImVec2* out_close_button_pos);
+ static void DockNodeCalcSplitRects(ImVec2& pos_old, ImVec2& size_old, ImVec2& pos_new, ImVec2& size_new, ImGuiDir dir, ImVec2 size_new_desired);
+ static bool DockNodeCalcDropRectsAndTestMousePos(const ImRect& parent, ImGuiDir dir, ImRect& out_draw, bool outer_docking, ImVec2* test_mouse_pos);
+ static const char* DockNodeGetHostWindowTitle(ImGuiDockNode* node, char* buf, int buf_size) { ImFormatString(buf, buf_size, "##DockNode_%02X", node->ID); return buf; }
+ static int DockNodeGetTabOrder(ImGuiWindow* window);
+
+ // ImGuiDockNode tree manipulations
+ static void DockNodeTreeSplit(ImGuiContext* ctx, ImGuiDockNode* parent_node, ImGuiAxis split_axis, int split_first_child, float split_ratio, ImGuiDockNode* new_node);
+ static void DockNodeTreeMerge(ImGuiContext* ctx, ImGuiDockNode* parent_node, ImGuiDockNode* merge_lead_child);
+ static void DockNodeTreeUpdatePosSize(ImGuiDockNode* node, ImVec2 pos, ImVec2 size, ImGuiDockNode* only_write_to_single_node = NULL);
+ static void DockNodeTreeUpdateSplitter(ImGuiDockNode* node);
+ static ImGuiDockNode* DockNodeTreeFindVisibleNodeByPos(ImGuiDockNode* node, ImVec2 pos);
+ static ImGuiDockNode* DockNodeTreeFindFallbackLeafNode(ImGuiDockNode* node);
+
+ // Settings
+ static void DockSettingsRenameNodeReferences(ImGuiID old_node_id, ImGuiID new_node_id);
+ static void DockSettingsRemoveNodeReferences(ImGuiID* node_ids, int node_ids_count);
+ static ImGuiDockNodeSettings* DockSettingsFindNodeSettings(ImGuiContext* ctx, ImGuiID node_id);
+ static void DockSettingsHandler_ClearAll(ImGuiContext*, ImGuiSettingsHandler*);
+ static void DockSettingsHandler_ApplyAll(ImGuiContext*, ImGuiSettingsHandler*);
+ static void* DockSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name);
+ static void DockSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line);
+ static void DockSettingsHandler_WriteAll(ImGuiContext* imgui_ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf);
+}
+
+//-----------------------------------------------------------------------------
+// Docking: ImGuiDockContext
+//-----------------------------------------------------------------------------
+// The lifetime model is different from the one of regular windows: we always create a ImGuiDockNode for each ImGuiDockNodeSettings,
+// or we always hold the entire docking node tree. Nodes are frequently hidden, e.g. if the window(s) or child nodes they host are not active.
+// At boot time only, we run a simple GC to remove nodes that have no references.
+// Because dock node settings (which are small, contiguous structures) are always mirrored by their corresponding dock nodes (more complete structures),
+// we can also very easily recreate the nodes from scratch given the settings data (this is what DockContextRebuild() does).
+// This is convenient as docking reconfiguration can be implemented by mostly poking at the simpler settings data.
+//-----------------------------------------------------------------------------
+// - DockContextInitialize()
+// - DockContextShutdown()
+// - DockContextClearNodes()
+// - DockContextRebuildNodes()
+// - DockContextNewFrameUpdateUndocking()
+// - DockContextNewFrameUpdateDocking()
+// - DockContextEndFrame()
+// - DockContextFindNodeByID()
+// - DockContextBindNodeToWindow()
+// - DockContextGenNodeID()
+// - DockContextAddNode()
+// - DockContextRemoveNode()
+// - ImGuiDockContextPruneNodeData
+// - DockContextPruneUnusedSettingsNodes()
+// - DockContextBuildNodesFromSettings()
+// - DockContextBuildAddWindowsToNodes()
+//-----------------------------------------------------------------------------
+
+void ImGui::DockContextInitialize(ImGuiContext* ctx)
+{
+ ImGuiContext& g = *ctx;
+
+ // Add .ini handle for persistent docking data
+ ImGuiSettingsHandler ini_handler;
+ ini_handler.TypeName = "Docking";
+ ini_handler.TypeHash = ImHashStr("Docking");
+ ini_handler.ClearAllFn = DockSettingsHandler_ClearAll;
+ ini_handler.ReadInitFn = DockSettingsHandler_ClearAll; // Also clear on read
+ ini_handler.ReadOpenFn = DockSettingsHandler_ReadOpen;
+ ini_handler.ReadLineFn = DockSettingsHandler_ReadLine;
+ ini_handler.ApplyAllFn = DockSettingsHandler_ApplyAll;
+ ini_handler.WriteAllFn = DockSettingsHandler_WriteAll;
+ g.SettingsHandlers.push_back(ini_handler);
+
+ g.DockNodeWindowMenuHandler = &DockNodeWindowMenuHandler_Default;
+}
+
+void ImGui::DockContextShutdown(ImGuiContext* ctx)
+{
+ ImGuiDockContext* dc = &ctx->DockContext;
+ for (int n = 0; n < dc->Nodes.Data.Size; n++)
+ if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
+ IM_DELETE(node);
+}
+
+void ImGui::DockContextClearNodes(ImGuiContext* ctx, ImGuiID root_id, bool clear_settings_refs)
+{
+ IM_UNUSED(ctx);
+ IM_ASSERT(ctx == GImGui);
+ DockBuilderRemoveNodeDockedWindows(root_id, clear_settings_refs);
+ DockBuilderRemoveNodeChildNodes(root_id);
+}
+
+// [DEBUG] This function also acts as a defacto test to make sure we can rebuild from scratch without a glitch
+// (Different from DockSettingsHandler_ClearAll() + DockSettingsHandler_ApplyAll() because this reuses current settings!)
+void ImGui::DockContextRebuildNodes(ImGuiContext* ctx)
+{
+ ImGuiContext& g = *ctx;
+ ImGuiDockContext* dc = &ctx->DockContext;
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextRebuildNodes\n");
+ SaveIniSettingsToMemory();
+ ImGuiID root_id = 0; // Rebuild all
+ DockContextClearNodes(ctx, root_id, false);
+ DockContextBuildNodesFromSettings(ctx, dc->NodesSettings.Data, dc->NodesSettings.Size);
+ DockContextBuildAddWindowsToNodes(ctx, root_id);
+}
+
+// Docking context update function, called by NewFrame()
+void ImGui::DockContextNewFrameUpdateUndocking(ImGuiContext* ctx)
+{
+ ImGuiContext& g = *ctx;
+ ImGuiDockContext* dc = &ctx->DockContext;
+ if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
+ {
+ if (dc->Nodes.Data.Size > 0 || dc->Requests.Size > 0)
+ DockContextClearNodes(ctx, 0, true);
+ return;
+ }
+
+ // Setting NoSplit at runtime merges all nodes
+ if (g.IO.ConfigDockingNoSplit)
+ for (int n = 0; n < dc->Nodes.Data.Size; n++)
+ if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
+ if (node->IsRootNode() && node->IsSplitNode())
+ {
+ DockBuilderRemoveNodeChildNodes(node->ID);
+ //dc->WantFullRebuild = true;
+ }
+
+ // Process full rebuild
+#if 0
+ if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_C)))
+ dc->WantFullRebuild = true;
+#endif
+ if (dc->WantFullRebuild)
+ {
+ DockContextRebuildNodes(ctx);
+ dc->WantFullRebuild = false;
+ }
+
+ // Process Undocking requests (we need to process them _before_ the UpdateMouseMovingWindowNewFrame call in NewFrame)
+ for (ImGuiDockRequest& req : dc->Requests)
+ {
+ if (req.Type == ImGuiDockRequestType_Undock && req.UndockTargetWindow)
+ DockContextProcessUndockWindow(ctx, req.UndockTargetWindow);
+ else if (req.Type == ImGuiDockRequestType_Undock && req.UndockTargetNode)
+ DockContextProcessUndockNode(ctx, req.UndockTargetNode);
+ }
+}
+
+// Docking context update function, called by NewFrame()
+void ImGui::DockContextNewFrameUpdateDocking(ImGuiContext* ctx)
+{
+ ImGuiContext& g = *ctx;
+ ImGuiDockContext* dc = &ctx->DockContext;
+ if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
+ return;
+
+ // [DEBUG] Store hovered dock node.
+ // We could in theory use DockNodeTreeFindVisibleNodeByPos() on the root host dock node, but using ->DockNode is a good shortcut.
+ // Note this is mostly a debug thing and isn't actually used for docking target, because docking involve more detailed filtering.
+ g.DebugHoveredDockNode = NULL;
+ if (ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow)
+ {
+ if (hovered_window->DockNodeAsHost)
+ g.DebugHoveredDockNode = DockNodeTreeFindVisibleNodeByPos(hovered_window->DockNodeAsHost, g.IO.MousePos);
+ else if (hovered_window->RootWindow->DockNode)
+ g.DebugHoveredDockNode = hovered_window->RootWindow->DockNode;
+ }
+
+ // Process Docking requests
+ for (ImGuiDockRequest& req : dc->Requests)
+ if (req.Type == ImGuiDockRequestType_Dock)
+ DockContextProcessDock(ctx, &req);
+ dc->Requests.resize(0);
+
+ // Create windows for each automatic docking nodes
+ // We can have NULL pointers when we delete nodes, but because ID are recycled this should amortize nicely (and our node count will never be very high)
+ for (int n = 0; n < dc->Nodes.Data.Size; n++)
+ if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
+ if (node->IsFloatingNode())
+ DockNodeUpdate(node);
+}
+
+void ImGui::DockContextEndFrame(ImGuiContext* ctx)
+{
+ // Draw backgrounds of node missing their window
+ ImGuiContext& g = *ctx;
+ ImGuiDockContext* dc = &g.DockContext;
+ for (int n = 0; n < dc->Nodes.Data.Size; n++)
+ if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
+ if (node->LastFrameActive == g.FrameCount && node->IsVisible && node->HostWindow && node->IsLeafNode() && !node->IsBgDrawnThisFrame)
+ {
+ ImRect bg_rect(node->Pos + ImVec2(0.0f, GetFrameHeight()), node->Pos + node->Size);
+ ImDrawFlags bg_rounding_flags = CalcRoundingFlagsForRectInRect(bg_rect, node->HostWindow->Rect(), g.Style.DockingSeparatorSize);
+ node->HostWindow->DrawList->ChannelsSetCurrent(DOCKING_HOST_DRAW_CHANNEL_BG);
+ node->HostWindow->DrawList->AddRectFilled(bg_rect.Min, bg_rect.Max, node->LastBgColor, node->HostWindow->WindowRounding, bg_rounding_flags);
+ }
+}
+
+ImGuiDockNode* ImGui::DockContextFindNodeByID(ImGuiContext* ctx, ImGuiID id)
+{
+ return (ImGuiDockNode*)ctx->DockContext.Nodes.GetVoidPtr(id);
+}
+
+ImGuiID ImGui::DockContextGenNodeID(ImGuiContext* ctx)
+{
+ // Generate an ID for new node (the exact ID value doesn't matter as long as it is not already used)
+ // FIXME-OPT FIXME-DOCK: This is suboptimal, even if the node count is small enough not to be a worry.0
+ // We should poke in ctx->Nodes to find a suitable ID faster. Even more so trivial that ctx->Nodes lookup is already sorted.
+ ImGuiID id = 0x0001;
+ while (DockContextFindNodeByID(ctx, id) != NULL)
+ id++;
+ return id;
+}
+
+static ImGuiDockNode* ImGui::DockContextAddNode(ImGuiContext* ctx, ImGuiID id)
+{
+ // Generate an ID for the new node (the exact ID value doesn't matter as long as it is not already used) and add the first window.
+ ImGuiContext& g = *ctx;
+ if (id == 0)
+ id = DockContextGenNodeID(ctx);
+ else
+ IM_ASSERT(DockContextFindNodeByID(ctx, id) == NULL);
+
+ // We don't set node->LastFrameAlive on construction. Nodes are always created at all time to reflect .ini settings!
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextAddNode 0x%08X\n", id);
+ ImGuiDockNode* node = IM_NEW(ImGuiDockNode)(id);
+ ctx->DockContext.Nodes.SetVoidPtr(node->ID, node);
+ return node;
+}
+
+static void ImGui::DockContextRemoveNode(ImGuiContext* ctx, ImGuiDockNode* node, bool merge_sibling_into_parent_node)
+{
+ ImGuiContext& g = *ctx;
+ ImGuiDockContext* dc = &ctx->DockContext;
+
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextRemoveNode 0x%08X\n", node->ID);
+ IM_ASSERT(DockContextFindNodeByID(ctx, node->ID) == node);
+ IM_ASSERT(node->ChildNodes[0] == NULL && node->ChildNodes[1] == NULL);
+ IM_ASSERT(node->Windows.Size == 0);
+
+ if (node->HostWindow)
+ node->HostWindow->DockNodeAsHost = NULL;
+
+ ImGuiDockNode* parent_node = node->ParentNode;
+ const bool merge = (merge_sibling_into_parent_node && parent_node != NULL);
+ if (merge)
+ {
+ IM_ASSERT(parent_node->ChildNodes[0] == node || parent_node->ChildNodes[1] == node);
+ ImGuiDockNode* sibling_node = (parent_node->ChildNodes[0] == node ? parent_node->ChildNodes[1] : parent_node->ChildNodes[0]);
+ DockNodeTreeMerge(&g, parent_node, sibling_node);
+ }
+ else
+ {
+ for (int n = 0; parent_node && n < IM_ARRAYSIZE(parent_node->ChildNodes); n++)
+ if (parent_node->ChildNodes[n] == node)
+ node->ParentNode->ChildNodes[n] = NULL;
+ dc->Nodes.SetVoidPtr(node->ID, NULL);
+ IM_DELETE(node);
+ }
+}
+
+static int IMGUI_CDECL DockNodeComparerDepthMostFirst(const void* lhs, const void* rhs)
+{
+ const ImGuiDockNode* a = *(const ImGuiDockNode* const*)lhs;
+ const ImGuiDockNode* b = *(const ImGuiDockNode* const*)rhs;
+ return ImGui::DockNodeGetDepth(b) - ImGui::DockNodeGetDepth(a);
+}
+
+// Pre C++0x doesn't allow us to use a function-local type (without linkage) as template parameter, so we moved this here.
+struct ImGuiDockContextPruneNodeData
+{
+ int CountWindows, CountChildWindows, CountChildNodes;
+ ImGuiID RootId;
+ ImGuiDockContextPruneNodeData() { CountWindows = CountChildWindows = CountChildNodes = 0; RootId = 0; }
+};
+
+// Garbage collect unused nodes (run once at init time)
+static void ImGui::DockContextPruneUnusedSettingsNodes(ImGuiContext* ctx)
+{
+ ImGuiContext& g = *ctx;
+ ImGuiDockContext* dc = &ctx->DockContext;
+ IM_ASSERT(g.Windows.Size == 0);
+
+ ImPool<ImGuiDockContextPruneNodeData> pool;
+ pool.Reserve(dc->NodesSettings.Size);
+
+ // Count child nodes and compute RootID
+ for (int settings_n = 0; settings_n < dc->NodesSettings.Size; settings_n++)
+ {
+ ImGuiDockNodeSettings* settings = &dc->NodesSettings[settings_n];
+ ImGuiDockContextPruneNodeData* parent_data = settings->ParentNodeId ? pool.GetByKey(settings->ParentNodeId) : 0;
+ pool.GetOrAddByKey(settings->ID)->RootId = parent_data ? parent_data->RootId : settings->ID;
+ if (settings->ParentNodeId)
+ pool.GetOrAddByKey(settings->ParentNodeId)->CountChildNodes++;
+ }
+
+ // Count reference to dock ids from dockspaces
+ // We track the 'auto-DockNode <- manual-Window <- manual-DockSpace' in order to avoid 'auto-DockNode' being ditched by DockContextPruneUnusedSettingsNodes()
+ for (int settings_n = 0; settings_n < dc->NodesSettings.Size; settings_n++)
+ {
+ ImGuiDockNodeSettings* settings = &dc->NodesSettings[settings_n];
+ if (settings->ParentWindowId != 0)
+ if (ImGuiWindowSettings* window_settings = FindWindowSettingsByID(settings->ParentWindowId))
+ if (window_settings->DockId)
+ if (ImGuiDockContextPruneNodeData* data = pool.GetByKey(window_settings->DockId))
+ data->CountChildNodes++;
+ }
+
+ // Count reference to dock ids from window settings
+ // We guard against the possibility of an invalid .ini file (RootID may point to a missing node)
+ for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
+ if (ImGuiID dock_id = settings->DockId)
+ if (ImGuiDockContextPruneNodeData* data = pool.GetByKey(dock_id))
+ {
+ data->CountWindows++;
+ if (ImGuiDockContextPruneNodeData* data_root = (data->RootId == dock_id) ? data : pool.GetByKey(data->RootId))
+ data_root->CountChildWindows++;
+ }
+
+ // Prune
+ for (int settings_n = 0; settings_n < dc->NodesSettings.Size; settings_n++)
+ {
+ ImGuiDockNodeSettings* settings = &dc->NodesSettings[settings_n];
+ ImGuiDockContextPruneNodeData* data = pool.GetByKey(settings->ID);
+ if (data->CountWindows > 1)
+ continue;
+ ImGuiDockContextPruneNodeData* data_root = (data->RootId == settings->ID) ? data : pool.GetByKey(data->RootId);
+
+ bool remove = false;
+ remove |= (data->CountWindows == 1 && settings->ParentNodeId == 0 && data->CountChildNodes == 0 && !(settings->Flags & ImGuiDockNodeFlags_CentralNode)); // Floating root node with only 1 window
+ remove |= (data->CountWindows == 0 && settings->ParentNodeId == 0 && data->CountChildNodes == 0); // Leaf nodes with 0 window
+ remove |= (data_root->CountChildWindows == 0);
+ if (remove)
+ {
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextPruneUnusedSettingsNodes: Prune 0x%08X\n", settings->ID);
+ DockSettingsRemoveNodeReferences(&settings->ID, 1);
+ settings->ID = 0;
+ }
+ }
+}
+
+static void ImGui::DockContextBuildNodesFromSettings(ImGuiContext* ctx, ImGuiDockNodeSettings* node_settings_array, int node_settings_count)
+{
+ // Build nodes
+ for (int node_n = 0; node_n < node_settings_count; node_n++)
+ {
+ ImGuiDockNodeSettings* settings = &node_settings_array[node_n];
+ if (settings->ID == 0)
+ continue;
+ ImGuiDockNode* node = DockContextAddNode(ctx, settings->ID);
+ node->ParentNode = settings->ParentNodeId ? DockContextFindNodeByID(ctx, settings->ParentNodeId) : NULL;
+ node->Pos = ImVec2(settings->Pos.x, settings->Pos.y);
+ node->Size = ImVec2(settings->Size.x, settings->Size.y);
+ node->SizeRef = ImVec2(settings->SizeRef.x, settings->SizeRef.y);
+ node->AuthorityForPos = node->AuthorityForSize = node->AuthorityForViewport = ImGuiDataAuthority_DockNode;
+ if (node->ParentNode && node->ParentNode->ChildNodes[0] == NULL)
+ node->ParentNode->ChildNodes[0] = node;
+ else if (node->ParentNode && node->ParentNode->ChildNodes[1] == NULL)
+ node->ParentNode->ChildNodes[1] = node;
+ node->SelectedTabId = settings->SelectedTabId;
+ node->SplitAxis = (ImGuiAxis)settings->SplitAxis;
+ node->SetLocalFlags(settings->Flags & ImGuiDockNodeFlags_SavedFlagsMask_);
+
+ // Bind host window immediately if it already exist (in case of a rebuild)
+ // This is useful as the RootWindowForTitleBarHighlight links necessary to highlight the currently focused node requires node->HostWindow to be set.
+ char host_window_title[20];
+ ImGuiDockNode* root_node = DockNodeGetRootNode(node);
+ node->HostWindow = FindWindowByName(DockNodeGetHostWindowTitle(root_node, host_window_title, IM_ARRAYSIZE(host_window_title)));
+ }
+}
+
+void ImGui::DockContextBuildAddWindowsToNodes(ImGuiContext* ctx, ImGuiID root_id)
+{
+ // Rebind all windows to nodes (they can also lazily rebind but we'll have a visible glitch during the first frame)
+ ImGuiContext& g = *ctx;
+ for (ImGuiWindow* window : g.Windows)
+ {
+ if (window->DockId == 0 || window->LastFrameActive < g.FrameCount - 1)
+ continue;
+ if (window->DockNode != NULL)
+ continue;
+
+ ImGuiDockNode* node = DockContextFindNodeByID(ctx, window->DockId);
+ IM_ASSERT(node != NULL); // This should have been called after DockContextBuildNodesFromSettings()
+ if (root_id == 0 || DockNodeGetRootNode(node)->ID == root_id)
+ DockNodeAddWindow(node, window, true);
+ }
+}
+
+//-----------------------------------------------------------------------------
+// Docking: ImGuiDockContext Docking/Undocking functions
+//-----------------------------------------------------------------------------
+// - DockContextQueueDock()
+// - DockContextQueueUndockWindow()
+// - DockContextQueueUndockNode()
+// - DockContextQueueNotifyRemovedNode()
+// - DockContextProcessDock()
+// - DockContextProcessUndockWindow()
+// - DockContextProcessUndockNode()
+// - DockContextCalcDropPosForDocking()
+//-----------------------------------------------------------------------------
+
+void ImGui::DockContextQueueDock(ImGuiContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer)
+{
+ IM_ASSERT(target != payload);
+ ImGuiDockRequest req;
+ req.Type = ImGuiDockRequestType_Dock;
+ req.DockTargetWindow = target;
+ req.DockTargetNode = target_node;
+ req.DockPayload = payload;
+ req.DockSplitDir = split_dir;
+ req.DockSplitRatio = split_ratio;
+ req.DockSplitOuter = split_outer;
+ ctx->DockContext.Requests.push_back(req);
+}
+
+void ImGui::DockContextQueueUndockWindow(ImGuiContext* ctx, ImGuiWindow* window)
+{
+ ImGuiDockRequest req;
+ req.Type = ImGuiDockRequestType_Undock;
+ req.UndockTargetWindow = window;
+ ctx->DockContext.Requests.push_back(req);
+}
+
+void ImGui::DockContextQueueUndockNode(ImGuiContext* ctx, ImGuiDockNode* node)
+{
+ ImGuiDockRequest req;
+ req.Type = ImGuiDockRequestType_Undock;
+ req.UndockTargetNode = node;
+ ctx->DockContext.Requests.push_back(req);
+}
+
+void ImGui::DockContextQueueNotifyRemovedNode(ImGuiContext* ctx, ImGuiDockNode* node)
+{
+ ImGuiDockContext* dc = &ctx->DockContext;
+ for (ImGuiDockRequest& req : dc->Requests)
+ if (req.DockTargetNode == node)
+ req.Type = ImGuiDockRequestType_None;
+}
+
+void ImGui::DockContextProcessDock(ImGuiContext* ctx, ImGuiDockRequest* req)
+{
+ IM_ASSERT((req->Type == ImGuiDockRequestType_Dock && req->DockPayload != NULL) || (req->Type == ImGuiDockRequestType_Split && req->DockPayload == NULL));
+ IM_ASSERT(req->DockTargetWindow != NULL || req->DockTargetNode != NULL);
+
+ ImGuiContext& g = *ctx;
+ IM_UNUSED(g);
+
+ ImGuiWindow* payload_window = req->DockPayload; // Optional
+ ImGuiWindow* target_window = req->DockTargetWindow;
+ ImGuiDockNode* node = req->DockTargetNode;
+ if (payload_window)
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextProcessDock node 0x%08X target '%s' dock window '%s', split_dir %d\n", node ? node->ID : 0, target_window ? target_window->Name : "NULL", payload_window->Name, req->DockSplitDir);
+ else
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextProcessDock node 0x%08X, split_dir %d\n", node ? node->ID : 0, req->DockSplitDir);
+
+ // Decide which Tab will be selected at the end of the operation
+ ImGuiID next_selected_id = 0;
+ ImGuiDockNode* payload_node = NULL;
+ if (payload_window)
+ {
+ payload_node = payload_window->DockNodeAsHost;
+ payload_window->DockNodeAsHost = NULL; // Important to clear this as the node will have its life as a child which might be merged/deleted later.
+ if (payload_node && payload_node->IsLeafNode())
+ next_selected_id = payload_node->TabBar->NextSelectedTabId ? payload_node->TabBar->NextSelectedTabId : payload_node->TabBar->SelectedTabId;
+ if (payload_node == NULL)
+ next_selected_id = payload_window->TabId;
+ }
+
+ // FIXME-DOCK: When we are trying to dock an existing single-window node into a loose window, transfer Node ID as well
+ // When processing an interactive split, usually LastFrameAlive will be < g.FrameCount. But DockBuilder operations can make it ==.
+ if (node)
+ IM_ASSERT(node->LastFrameAlive <= g.FrameCount);
+ if (node && target_window && node == target_window->DockNodeAsHost)
+ IM_ASSERT(node->Windows.Size > 0 || node->IsSplitNode() || node->IsCentralNode());
+
+ // Create new node and add existing window to it
+ if (node == NULL)
+ {
+ node = DockContextAddNode(ctx, 0);
+ node->Pos = target_window->Pos;
+ node->Size = target_window->Size;
+ if (target_window->DockNodeAsHost == NULL)
+ {
+ DockNodeAddWindow(node, target_window, true);
+ node->TabBar->Tabs[0].Flags &= ~ImGuiTabItemFlags_Unsorted;
+ target_window->DockIsActive = true;
+ }
+ }
+
+ ImGuiDir split_dir = req->DockSplitDir;
+ if (split_dir != ImGuiDir_None)
+ {
+ // Split into two, one side will be our payload node unless we are dropping a loose window
+ const ImGuiAxis split_axis = (split_dir == ImGuiDir_Left || split_dir == ImGuiDir_Right) ? ImGuiAxis_X : ImGuiAxis_Y;
+ const int split_inheritor_child_idx = (split_dir == ImGuiDir_Left || split_dir == ImGuiDir_Up) ? 1 : 0; // Current contents will be moved to the opposite side
+ const float split_ratio = req->DockSplitRatio;
+ DockNodeTreeSplit(ctx, node, split_axis, split_inheritor_child_idx, split_ratio, payload_node); // payload_node may be NULL here!
+ ImGuiDockNode* new_node = node->ChildNodes[split_inheritor_child_idx ^ 1];
+ new_node->HostWindow = node->HostWindow;
+ node = new_node;
+ }
+ node->SetLocalFlags(node->LocalFlags & ~ImGuiDockNodeFlags_HiddenTabBar);
+
+ if (node != payload_node)
+ {
+ // Create tab bar before we call DockNodeMoveWindows (which would attempt to move the old tab-bar, which would lead us to payload tabs wrongly appearing before target tabs!)
+ if (node->Windows.Size > 0 && node->TabBar == NULL)
+ {
+ DockNodeAddTabBar(node);
+ for (int n = 0; n < node->Windows.Size; n++)
+ TabBarAddTab(node->TabBar, ImGuiTabItemFlags_None, node->Windows[n]);
+ }
+
+ if (payload_node != NULL)
+ {
+ // Transfer full payload node (with 1+ child windows or child nodes)
+ if (payload_node->IsSplitNode())
+ {
+ if (node->Windows.Size > 0)
+ {
+ // We can dock a split payload into a node that already has windows _only_ if our payload is a node tree with a single visible node.
+ // In this situation, we move the windows of the target node into the currently visible node of the payload.
+ // This allows us to preserve some of the underlying dock tree settings nicely.
+ IM_ASSERT(payload_node->OnlyNodeWithWindows != NULL); // The docking should have been blocked by DockNodePreviewDockSetup() early on and never submitted.
+ ImGuiDockNode* visible_node = payload_node->OnlyNodeWithWindows;
+ if (visible_node->TabBar)
+ IM_ASSERT(visible_node->TabBar->Tabs.Size > 0);
+ DockNodeMoveWindows(node, visible_node);
+ DockNodeMoveWindows(visible_node, node);
+ DockSettingsRenameNodeReferences(node->ID, visible_node->ID);
+ }
+ if (node->IsCentralNode())
+ {
+ // Central node property needs to be moved to a leaf node, pick the last focused one.
+ // FIXME-DOCK: If we had to transfer other flags here, what would the policy be?
+ ImGuiDockNode* last_focused_node = DockContextFindNodeByID(ctx, payload_node->LastFocusedNodeId);
+ IM_ASSERT(last_focused_node != NULL);
+ ImGuiDockNode* last_focused_root_node = DockNodeGetRootNode(last_focused_node);
+ IM_ASSERT(last_focused_root_node == DockNodeGetRootNode(payload_node));
+ last_focused_node->SetLocalFlags(last_focused_node->LocalFlags | ImGuiDockNodeFlags_CentralNode);
+ node->SetLocalFlags(node->LocalFlags & ~ImGuiDockNodeFlags_CentralNode);
+ last_focused_root_node->CentralNode = last_focused_node;
+ }
+
+ IM_ASSERT(node->Windows.Size == 0);
+ DockNodeMoveChildNodes(node, payload_node);
+ }
+ else
+ {
+ const ImGuiID payload_dock_id = payload_node->ID;
+ DockNodeMoveWindows(node, payload_node);
+ DockSettingsRenameNodeReferences(payload_dock_id, node->ID);
+ }
+ DockContextRemoveNode(ctx, payload_node, true);
+ }
+ else if (payload_window)
+ {
+ // Transfer single window
+ const ImGuiID payload_dock_id = payload_window->DockId;
+ node->VisibleWindow = payload_window;
+ DockNodeAddWindow(node, payload_window, true);
+ if (payload_dock_id != 0)
+ DockSettingsRenameNodeReferences(payload_dock_id, node->ID);
+ }
+ }
+ else
+ {
+ // When docking a floating single window node we want to reevaluate auto-hiding of the tab bar
+ node->WantHiddenTabBarUpdate = true;
+ }
+
+ // Update selection immediately
+ if (ImGuiTabBar* tab_bar = node->TabBar)
+ tab_bar->NextSelectedTabId = next_selected_id;
+ MarkIniSettingsDirty();
+}
+
+// Problem:
+// Undocking a large (~full screen) window would leave it so large that the bottom right sizing corner would more
+// than likely be off the screen and the window would be hard to resize to fit on screen. This can be particularly problematic
+// with 'ConfigWindowsMoveFromTitleBarOnly=true' and/or with 'ConfigWindowsResizeFromEdges=false' as well (the later can be
+// due to missing ImGuiBackendFlags_HasMouseCursors backend flag).
+// Solution:
+// When undocking a window we currently force its maximum size to 90% of the host viewport or monitor.
+// Reevaluate this when we implement preserving docked/undocked size ("docking_wip/undocked_size" branch).
+static ImVec2 FixLargeWindowsWhenUndocking(const ImVec2& size, ImGuiViewport* ref_viewport)
+{
+ if (ref_viewport == NULL)
+ return size;
+
+ ImGuiContext& g = *GImGui;
+ ImVec2 max_size = ImTrunc(ref_viewport->WorkSize * 0.90f);
+ if (g.ConfigFlagsCurrFrame & ImGuiConfigFlags_ViewportsEnable)
+ {
+ const ImGuiPlatformMonitor* monitor = ImGui::GetViewportPlatformMonitor(ref_viewport);
+ max_size = ImTrunc(monitor->WorkSize * 0.90f);
+ }
+ return ImMin(size, max_size);
+}
+
+void ImGui::DockContextProcessUndockWindow(ImGuiContext* ctx, ImGuiWindow* window, bool clear_persistent_docking_ref)
+{
+ ImGuiContext& g = *ctx;
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextProcessUndockWindow window '%s', clear_persistent_docking_ref = %d\n", window->Name, clear_persistent_docking_ref);
+ if (window->DockNode)
+ DockNodeRemoveWindow(window->DockNode, window, clear_persistent_docking_ref ? 0 : window->DockId);
+ else
+ window->DockId = 0;
+ window->Collapsed = false;
+ window->DockIsActive = false;
+ window->DockNodeIsVisible = window->DockTabIsVisible = false;
+ window->Size = window->SizeFull = FixLargeWindowsWhenUndocking(window->SizeFull, window->Viewport);
+
+ MarkIniSettingsDirty();
+}
+
+void ImGui::DockContextProcessUndockNode(ImGuiContext* ctx, ImGuiDockNode* node)
+{
+ ImGuiContext& g = *ctx;
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockContextProcessUndockNode node %08X\n", node->ID);
+ IM_ASSERT(node->IsLeafNode());
+ IM_ASSERT(node->Windows.Size >= 1);
+
+ if (node->IsRootNode() || node->IsCentralNode())
+ {
+ // In the case of a root node or central node, the node will have to stay in place. Create a new node to receive the payload.
+ ImGuiDockNode* new_node = DockContextAddNode(ctx, 0);
+ new_node->Pos = node->Pos;
+ new_node->Size = node->Size;
+ new_node->SizeRef = node->SizeRef;
+ DockNodeMoveWindows(new_node, node);
+ DockSettingsRenameNodeReferences(node->ID, new_node->ID);
+ node = new_node;
+ }
+ else
+ {
+ // Otherwise extract our node and merge our sibling back into the parent node.
+ IM_ASSERT(node->ParentNode->ChildNodes[0] == node || node->ParentNode->ChildNodes[1] == node);
+ int index_in_parent = (node->ParentNode->ChildNodes[0] == node) ? 0 : 1;
+ node->ParentNode->ChildNodes[index_in_parent] = NULL;
+ DockNodeTreeMerge(ctx, node->ParentNode, node->ParentNode->ChildNodes[index_in_parent ^ 1]);
+ node->ParentNode->AuthorityForViewport = ImGuiDataAuthority_Window; // The node that stays in place keeps the viewport, so our newly dragged out node will create a new viewport
+ node->ParentNode = NULL;
+ }
+ for (ImGuiWindow* window : node->Windows)
+ {
+ window->Flags &= ~ImGuiWindowFlags_ChildWindow;
+ if (window->ParentWindow)
+ window->ParentWindow->DC.ChildWindows.find_erase(window);
+ UpdateWindowParentAndRootLinks(window, window->Flags, NULL);
+ }
+ node->AuthorityForPos = node->AuthorityForSize = ImGuiDataAuthority_DockNode;
+ node->Size = FixLargeWindowsWhenUndocking(node->Size, node->Windows[0]->Viewport);
+ node->WantMouseMove = true;
+ MarkIniSettingsDirty();
+}
+
+// This is mostly used for automation.
+bool ImGui::DockContextCalcDropPosForDocking(ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload_window, ImGuiDockNode* payload_node, ImGuiDir split_dir, bool split_outer, ImVec2* out_pos)
+{
+ if (target != NULL && target_node == NULL)
+ target_node = target->DockNode;
+
+ // In DockNodePreviewDockSetup() for a root central node instead of showing both "inner" and "outer" drop rects
+ // (which would be functionally identical) we only show the outer one. Reflect this here.
+ if (target_node && target_node->ParentNode == NULL && target_node->IsCentralNode() && split_dir != ImGuiDir_None)
+ split_outer = true;
+ ImGuiDockPreviewData split_data;
+ DockNodePreviewDockSetup(target, target_node, payload_window, payload_node, &split_data, false, split_outer);
+ if (split_data.DropRectsDraw[split_dir+1].IsInverted())
+ return false;
+ *out_pos = split_data.DropRectsDraw[split_dir+1].GetCenter();
+ return true;
+}
+
+//-----------------------------------------------------------------------------
+// Docking: ImGuiDockNode
+//-----------------------------------------------------------------------------
+// - DockNodeGetTabOrder()
+// - DockNodeAddWindow()
+// - DockNodeRemoveWindow()
+// - DockNodeMoveChildNodes()
+// - DockNodeMoveWindows()
+// - DockNodeApplyPosSizeToWindows()
+// - DockNodeHideHostWindow()
+// - ImGuiDockNodeFindInfoResults
+// - DockNodeFindInfo()
+// - DockNodeFindWindowByID()
+// - DockNodeUpdateFlagsAndCollapse()
+// - DockNodeUpdateHasCentralNodeFlag()
+// - DockNodeUpdateVisibleFlag()
+// - DockNodeStartMouseMovingWindow()
+// - DockNodeUpdate()
+// - DockNodeUpdateWindowMenu()
+// - DockNodeBeginAmendTabBar()
+// - DockNodeEndAmendTabBar()
+// - DockNodeUpdateTabBar()
+// - DockNodeAddTabBar()
+// - DockNodeRemoveTabBar()
+// - DockNodeIsDropAllowedOne()
+// - DockNodeIsDropAllowed()
+// - DockNodeCalcTabBarLayout()
+// - DockNodeCalcSplitRects()
+// - DockNodeCalcDropRectsAndTestMousePos()
+// - DockNodePreviewDockSetup()
+// - DockNodePreviewDockRender()
+//-----------------------------------------------------------------------------
+
+ImGuiDockNode::ImGuiDockNode(ImGuiID id)
+{
+ ID = id;
+ SharedFlags = LocalFlags = LocalFlagsInWindows = MergedFlags = ImGuiDockNodeFlags_None;
+ ParentNode = ChildNodes[0] = ChildNodes[1] = NULL;
+ TabBar = NULL;
+ SplitAxis = ImGuiAxis_None;
+
+ State = ImGuiDockNodeState_Unknown;
+ LastBgColor = IM_COL32_WHITE;
+ HostWindow = VisibleWindow = NULL;
+ CentralNode = OnlyNodeWithWindows = NULL;
+ CountNodeWithWindows = 0;
+ LastFrameAlive = LastFrameActive = LastFrameFocused = -1;
+ LastFocusedNodeId = 0;
+ SelectedTabId = 0;
+ WantCloseTabId = 0;
+ RefViewportId = 0;
+ AuthorityForPos = AuthorityForSize = ImGuiDataAuthority_DockNode;
+ AuthorityForViewport = ImGuiDataAuthority_Auto;
+ IsVisible = true;
+ IsFocused = HasCloseButton = HasWindowMenuButton = HasCentralNodeChild = false;
+ IsBgDrawnThisFrame = false;
+ WantCloseAll = WantLockSizeOnce = WantMouseMove = WantHiddenTabBarUpdate = WantHiddenTabBarToggle = false;
+}
+
+ImGuiDockNode::~ImGuiDockNode()
+{
+ IM_DELETE(TabBar);
+ TabBar = NULL;
+ ChildNodes[0] = ChildNodes[1] = NULL;
+}
+
+int ImGui::DockNodeGetTabOrder(ImGuiWindow* window)
+{
+ ImGuiTabBar* tab_bar = window->DockNode->TabBar;
+ if (tab_bar == NULL)
+ return -1;
+ ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, window->TabId);
+ return tab ? TabBarGetTabOrder(tab_bar, tab) : -1;
+}
+
+static void DockNodeHideWindowDuringHostWindowCreation(ImGuiWindow* window)
+{
+ window->Hidden = true;
+ window->HiddenFramesCanSkipItems = window->Active ? 1 : 2;
+}
+
+static void ImGui::DockNodeAddWindow(ImGuiDockNode* node, ImGuiWindow* window, bool add_to_tab_bar)
+{
+ ImGuiContext& g = *GImGui; (void)g;
+ if (window->DockNode)
+ {
+ // Can overwrite an existing window->DockNode (e.g. pointing to a disabled DockSpace node)
+ IM_ASSERT(window->DockNode->ID != node->ID);
+ DockNodeRemoveWindow(window->DockNode, window, 0);
+ }
+ IM_ASSERT(window->DockNode == NULL || window->DockNodeAsHost == NULL);
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockNodeAddWindow node 0x%08X window '%s'\n", node->ID, window->Name);
+
+ // If more than 2 windows appeared on the same frame leading to the creation of a new hosting window,
+ // we'll hide windows until the host window is ready. Hide the 1st window after its been output (so it is not visible for one frame).
+ // We will call DockNodeHideWindowDuringHostWindowCreation() on ourselves in Begin()
+ if (node->HostWindow == NULL && node->Windows.Size == 1 && node->Windows[0]->WasActive == false)
+ DockNodeHideWindowDuringHostWindowCreation(node->Windows[0]);
+
+ node->Windows.push_back(window);
+ node->WantHiddenTabBarUpdate = true;
+ window->DockNode = node;
+ window->DockId = node->ID;
+ window->DockIsActive = (node->Windows.Size > 1);
+ window->DockTabWantClose = false;
+
+ // When reactivating a node with one or two loose window, the window pos/size/viewport are authoritative over the node storage.
+ // In particular it is important we init the viewport from the first window so we don't create two viewports and drop one.
+ if (node->HostWindow == NULL && node->IsFloatingNode())
+ {
+ if (node->AuthorityForPos == ImGuiDataAuthority_Auto)
+ node->AuthorityForPos = ImGuiDataAuthority_Window;
+ if (node->AuthorityForSize == ImGuiDataAuthority_Auto)
+ node->AuthorityForSize = ImGuiDataAuthority_Window;
+ if (node->AuthorityForViewport == ImGuiDataAuthority_Auto)
+ node->AuthorityForViewport = ImGuiDataAuthority_Window;
+ }
+
+ // Add to tab bar if requested
+ if (add_to_tab_bar)
+ {
+ if (node->TabBar == NULL)
+ {
+ DockNodeAddTabBar(node);
+ node->TabBar->SelectedTabId = node->TabBar->NextSelectedTabId = node->SelectedTabId;
+
+ // Add existing windows
+ for (int n = 0; n < node->Windows.Size - 1; n++)
+ TabBarAddTab(node->TabBar, ImGuiTabItemFlags_None, node->Windows[n]);
+ }
+ TabBarAddTab(node->TabBar, ImGuiTabItemFlags_Unsorted, window);
+ }
+
+ DockNodeUpdateVisibleFlag(node);
+
+ // Update this without waiting for the next time we Begin() in the window, so our host window will have the proper title bar color on its first frame.
+ if (node->HostWindow)
+ UpdateWindowParentAndRootLinks(window, window->Flags | ImGuiWindowFlags_ChildWindow, node->HostWindow);
+}
+
+static void ImGui::DockNodeRemoveWindow(ImGuiDockNode* node, ImGuiWindow* window, ImGuiID save_dock_id)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(window->DockNode == node);
+ //IM_ASSERT(window->RootWindowDockTree == node->HostWindow);
+ //IM_ASSERT(window->LastFrameActive < g.FrameCount); // We may call this from Begin()
+ IM_ASSERT(save_dock_id == 0 || save_dock_id == node->ID);
+ IMGUI_DEBUG_LOG_DOCKING("[docking] DockNodeRemoveWindow node 0x%08X window '%s'\n", node->ID, window->Name);
+
+ window->DockNode = NULL;
+ window->DockIsActive = window->DockTabWantClose = false;
+ window->DockId = save_dock_id;
+ window->Flags &= ~ImGuiWindowFlags_ChildWindow;
+ if (window->ParentWindow)
+ window->ParentWindow->DC.ChildWindows.find_erase(window);
+ UpdateWindowParentAndRootLinks(window, window->Flags, NULL); // Update immediately
+
+ if (node->HostWindow && node->HostWindow->ViewportOwned)
+ {
+ // When undocking from a user interaction this will always run in NewFrame() and have not much effect.
+ // But mid-frame, if we clear viewport we need to mark window as hidden as well.
+ window->Viewport = NULL;
+ window->ViewportId = 0;
+ window->ViewportOwned = false;
+ window->Hidden = true;
+ }
+
+ // Remove window
+ bool erased = false;
+ for (int n = 0; n < node->Windows.Size; n++)
+ if (node->Windows[n] == window)
+ {
+ node->Windows.erase(node->Windows.Data + n);
+ erased = true;
+ break;
+ }
+ if (!erased)
+ IM_ASSERT(erased);
+ if (node->VisibleWindow == window)
+ node->VisibleWindow = NULL;
+
+ // Remove tab and possibly tab bar
+ node->WantHiddenTabBarUpdate = true;
+ if (node->TabBar)
+ {
+ TabBarRemoveTab(node->TabBar, window->TabId);
+ const int tab_count_threshold_for_tab_bar = node->IsCentralNode() ? 1 : 2;
+ if (node->Windows.Size < tab_count_threshold_for_tab_bar)
+ DockNodeRemoveTabBar(node);
+ }
+
+ if (node->Windows.Size == 0 && !node->IsCentralNode() && !node->IsDockSpace() && window->DockId != node->ID)
+ {
+ // Automatic dock node delete themselves if they are not holding at least one tab
+ DockContextRemoveNode(&g, node, true);
+ return;
+ }
+
+ if (node->Windows.Size == 1 && !node->IsCentralNode() && node->HostWindow)
+ {
+ ImGuiWindow* remaining_window = node->Windows[0];
+ // Note: we used to transport viewport ownership here.
+ remaining_window->Collapsed = node->HostWindow->Collapsed;
+ }
+
+ // Update visibility immediately is required so the DockNodeUpdateRemoveInactiveChilds() processing can reflect changes up the tree
+ DockNodeUpdateVisibleFlag(node);
+}
+
+static void ImGui::DockNodeMoveChildNodes(ImGuiDockNode* dst_node, ImGuiDockNode* src_node)
+{
+ IM_ASSERT(dst_node->Windows.Size == 0);
+ dst_node->ChildNodes[0] = src_node->ChildNodes[0];
+ dst_node->ChildNodes[1] = src_node->ChildNodes[1];
+ if (dst_node->ChildNodes[0])
+ dst_node->ChildNodes[0]->ParentNode = dst_node;
+ if (dst_node->ChildNodes[1])
+ dst_node->ChildNodes[1]->ParentNode = dst_node;
+ dst_node->SplitAxis = src_node->SplitAxis;
+ dst_node->SizeRef = src_node->SizeRef;
+ src_node->ChildNodes[0] = src_node->ChildNodes[1] = NULL;
+}
+
+static void ImGui::DockNodeMoveWindows(ImGuiDockNode* dst_node, ImGuiDockNode* src_node)
+{
+ // Insert tabs in the same orders as currently ordered (node->Windows isn't ordered)
+ IM_ASSERT(src_node && dst_node && dst_node != src_node);
+ ImGuiTabBar* src_tab_bar = src_node->TabBar;
+ if (src_tab_bar != NULL)
+ IM_ASSERT(src_node->Windows.Size <= src_node->TabBar->Tabs.Size);
+
+ // If the dst_node is empty we can just move the entire tab bar (to preserve selection, scrolling, etc.)
+ bool move_tab_bar = (src_tab_bar != NULL) && (dst_node->TabBar == NULL);
+ if (move_tab_bar)
+ {
+ dst_node->TabBar = src_node->TabBar;
+ src_node->TabBar = NULL;
+ }
+
+ // Tab order is not important here, it is preserved by sorting in DockNodeUpdateTabBar().
+ for (ImGuiWindow* window : src_node->Windows)
+ {
+ window->DockNode = NULL;
+ window->DockIsActive = false;
+ DockNodeAddWindow(dst_node, window, !move_tab_bar);
+ }
+ src_node->Windows.clear();
+
+ if (!move_tab_bar && src_node->TabBar)
+ {
+ if (dst_node->TabBar)
+ dst_node->TabBar->SelectedTabId = src_node->TabBar->SelectedTabId;
+ DockNodeRemoveTabBar(src_node);
+ }
+}
+
+static void ImGui::DockNodeApplyPosSizeToWindows(ImGuiDockNode* node)
+{
+ for (ImGuiWindow* window : node->Windows)
+ {
+ SetWindowPos(window, node->Pos, ImGuiCond_Always); // We don't assign directly to Pos because it can break the calculation of SizeContents on next frame
+ SetWindowSize(window, node->Size, ImGuiCond_Always);
+ }
+}
+
+static void ImGui::DockNodeHideHostWindow(ImGuiDockNode* node)
+{
+ if (node->HostWindow)
+ {
+ if (node->HostWindow->DockNodeAsHost == node)
+ node->HostWindow->DockNodeAsHost = NULL;
+ node->HostWindow = NULL;
+ }
+
+ if (node->Windows.Size == 1)
+ {
+ node->VisibleWindow = node->Windows[0];
+ node->Windows[0]->DockIsActive = false;
+ }
+
+ if (node->TabBar)
+ DockNodeRemoveTabBar(node);
+}
+
+// Search function called once by root node in DockNodeUpdate()
+struct ImGuiDockNodeTreeInfo
+{
+ ImGuiDockNode* CentralNode;
+ ImGuiDockNode* FirstNodeWithWindows;
+ int CountNodesWithWindows;
+ //ImGuiWindowClass WindowClassForMerges;
+
+ ImGuiDockNodeTreeInfo() { memset(this, 0, sizeof(*this)); }
+};
+
+static void DockNodeFindInfo(ImGuiDockNode* node, ImGuiDockNodeTreeInfo* info)
+{
+ if (node->Windows.Size > 0)
+ {
+ if (info->FirstNodeWithWindows == NULL)
+ info->FirstNodeWithWindows = node;
+ info->CountNodesWithWindows++;
+ }
+ if (node->IsCentralNode())
+ {
+ IM_ASSERT(info->CentralNode == NULL); // Should be only one
+ IM_ASSERT(node->IsLeafNode() && "If you get this assert: please submit .ini file + repro of actions leading to this.");
+ info->CentralNode = node;
+ }
+ if (info->CountNodesWithWindows > 1 && info->CentralNode != NULL)
+ return;
+ if (node->ChildNodes[0])
+ DockNodeFindInfo(node->ChildNodes[0], info);
+ if (node->ChildNodes[1])
+ DockNodeFindInfo(node->ChildNodes[1], info);
+}
+
+static ImGuiWindow* ImGui::DockNodeFindWindowByID(ImGuiDockNode* node, ImGuiID id)
+{
+ IM_ASSERT(id != 0);
+ for (ImGuiWindow* window : node->Windows)
+ if (window->ID == id)
+ return window;
+ return NULL;
+}
+
+// - Remove inactive windows/nodes.
+// - Update visibility flag.
+static void ImGui::DockNodeUpdateFlagsAndCollapse(ImGuiDockNode* node)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(node->ParentNode == NULL || node->ParentNode->ChildNodes[0] == node || node->ParentNode->ChildNodes[1] == node);
+
+ // Inherit most flags
+ if (node->ParentNode)
+ node->SharedFlags = node->ParentNode->SharedFlags & ImGuiDockNodeFlags_SharedFlagsInheritMask_;
+
+ // Recurse into children
+ // There is the possibility that one of our child becoming empty will delete itself and moving its sibling contents into 'node'.
+ // If 'node->ChildNode[0]' delete itself, then 'node->ChildNode[1]->Windows' will be moved into 'node'
+ // If 'node->ChildNode[1]' delete itself, then 'node->ChildNode[0]->Windows' will be moved into 'node' and the "remove inactive windows" loop will have run twice on those windows (harmless)
+ node->HasCentralNodeChild = false;
+ if (node->ChildNodes[0])
+ DockNodeUpdateFlagsAndCollapse(node->ChildNodes[0]);
+ if (node->ChildNodes[1])
+ DockNodeUpdateFlagsAndCollapse(node->ChildNodes[1]);
+
+ // Remove inactive windows, collapse nodes
+ // Merge node flags overrides stored in windows
+ node->LocalFlagsInWindows = ImGuiDockNodeFlags_None;
+ for (int window_n = 0; window_n < node->Windows.Size; window_n++)
+ {
+ ImGuiWindow* window = node->Windows[window_n];
+ IM_ASSERT(window->DockNode == node);
+
+ bool node_was_active = (node->LastFrameActive + 1 == g.FrameCount);
+ bool remove = false;
+ remove |= node_was_active && (window->LastFrameActive + 1 < g.FrameCount);
+ remove |= node_was_active && (node->WantCloseAll || node->WantCloseTabId == window->TabId) && window->HasCloseButton && !(window->Flags & ImGuiWindowFlags_UnsavedDocument); // Submit all _expected_ closure from last frame
+ remove |= (window->DockTabWantClose);
+ if (remove)
+ {
+ window->DockTabWantClose = false;
+ if (node->Windows.Size == 1 && !node->IsCentralNode())
+ {
+ DockNodeHideHostWindow(node);
+ node->State = ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow;
+ DockNodeRemoveWindow(node, window, node->ID); // Will delete the node so it'll be invalid on return
+ return;
+ }
+ DockNodeRemoveWindow(node, window, node->ID);
+ window_n--;
+ continue;
+ }
+
+ // FIXME-DOCKING: Missing policies for conflict resolution, hence the "Experimental" tag on this.
+ //node->LocalFlagsInWindow &= ~window->WindowClass.DockNodeFlagsOverrideClear;
+ node->LocalFlagsInWindows |= window->WindowClass.DockNodeFlagsOverrideSet;
+ }
+ node->UpdateMergedFlags();
+
+ // Auto-hide tab bar option
+ ImGuiDockNodeFlags node_flags = node->MergedFlags;
+ if (node->WantHiddenTabBarUpdate && node->Windows.Size == 1 && (node_flags & ImGuiDockNodeFlags_AutoHideTabBar) && !node->IsHiddenTabBar())
+ node->WantHiddenTabBarToggle = true;
+ node->WantHiddenTabBarUpdate = false;
+
+ // Cancel toggling if we know our tab bar is enforced to be hidden at all times
+ if (node->WantHiddenTabBarToggle && node->VisibleWindow && (node->VisibleWindow->WindowClass.DockNodeFlagsOverrideSet & ImGuiDockNodeFlags_HiddenTabBar))
+ node->WantHiddenTabBarToggle = false;
+
+ // Apply toggles at a single point of the frame (here!)
+ if (node->Windows.Size > 1)
+ node->SetLocalFlags(node->LocalFlags & ~ImGuiDockNodeFlags_HiddenTabBar);
+ else if (node->WantHiddenTabBarToggle)
+ node->SetLocalFlags(node->LocalFlags ^ ImGuiDockNodeFlags_HiddenTabBar);
+ node->WantHiddenTabBarToggle = false;
+
+ DockNodeUpdateVisibleFlag(node);
+}
+
+// This is rarely called as DockNodeUpdateForRootNode() generally does it most frames.
+static void ImGui::DockNodeUpdateHasCentralNodeChild(ImGuiDockNode* node)
+{
+ node->HasCentralNodeChild = false;
+ if (node->ChildNodes[0])
+ DockNodeUpdateHasCentralNodeChild(node->ChildNodes[0]);
+ if (node->ChildNodes[1])
+ DockNodeUpdateHasCentralNodeChild(node->ChildNodes[1]);
+ if (node->IsRootNode())
+ {
+ ImGuiDockNode* mark_node = node->CentralNode;
+ while (mark_node)
+ {
+ mark_node->HasCentralNodeChild = true;
+ mark_node = mark_node->ParentNode;
+ }
+ }
+}
+
+static void ImGui::DockNodeUpdateVisibleFlag(ImGuiDockNode* node)
+{
+ // Update visibility flag
+ bool is_visible = (node->ParentNode == NULL) ? node->IsDockSpace() : node->IsCentralNode();
+ is_visible |= (node->Windows.Size > 0);
+ is_visible |= (node->ChildNodes[0] && node->ChildNodes[0]->IsVisible);
+ is_visible |= (node->ChildNodes[1] && node->ChildNodes[1]->IsVisible);
+ node->IsVisible = is_visible;
+}
+
+static void ImGui::DockNodeStartMouseMovingWindow(ImGuiDockNode* node, ImGuiWindow* window)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(node->WantMouseMove == true);
+ StartMouseMovingWindow(window);
+ g.ActiveIdClickOffset = g.IO.MouseClickedPos[0] - node->Pos;
+ g.MovingWindow = window; // If we are docked into a non moveable root window, StartMouseMovingWindow() won't set g.MovingWindow. Override that decision.
+ node->WantMouseMove = false;
+}
+
+// Update CentralNode, OnlyNodeWithWindows, LastFocusedNodeID. Copy window class.
+static void ImGui::DockNodeUpdateForRootNode(ImGuiDockNode* node)
+{
+ DockNodeUpdateFlagsAndCollapse(node);
+
+ // - Setup central node pointers
+ // - Find if there's only a single visible window in the hierarchy (in which case we need to display a regular title bar -> FIXME-DOCK: that last part is not done yet!)
+ // Cannot merge this with DockNodeUpdateFlagsAndCollapse() because FirstNodeWithWindows is found after window removal and child collapsing
+ ImGuiDockNodeTreeInfo info;
+ DockNodeFindInfo(node, &info);
+ node->CentralNode = info.CentralNode;
+ node->OnlyNodeWithWindows = (info.CountNodesWithWindows == 1) ? info.FirstNodeWithWindows : NULL;
+ node->CountNodeWithWindows = info.CountNodesWithWindows;
+ if (node->LastFocusedNodeId == 0 && info.FirstNodeWithWindows != NULL)
+ node->LastFocusedNodeId = info.FirstNodeWithWindows->ID;
+
+ // Copy the window class from of our first window so it can be used for proper dock filtering.
+ // When node has mixed windows, prioritize the class with the most constraint (DockingAllowUnclassed = false) as the reference to copy.
+ // FIXME-DOCK: We don't recurse properly, this code could be reworked to work from DockNodeUpdateScanRec.
+ if (ImGuiDockNode* first_node_with_windows = info.FirstNodeWithWindows)
+ {
+ node->WindowClass = first_node_with_windows->Windows[0]->WindowClass;
+ for (int n = 1; n < first_node_with_windows->Windows.Size; n++)
+ if (first_node_with_windows->Windows[n]->WindowClass.DockingAllowUnclassed == false)
+ {
+ node->WindowClass = first_node_with_windows->Windows[n]->WindowClass;
+ break;
+ }
+ }
+
+ ImGuiDockNode* mark_node = node->CentralNode;
+ while (mark_node)
+ {
+ mark_node->HasCentralNodeChild = true;
+ mark_node = mark_node->ParentNode;
+ }
+}
+
+static void DockNodeSetupHostWindow(ImGuiDockNode* node, ImGuiWindow* host_window)
+{
+ // Remove ourselves from any previous different host window
+ // This can happen if a user mistakenly does (see #4295 for details):
+ // - N+0: DockBuilderAddNode(id, 0) // missing ImGuiDockNodeFlags_DockSpace
+ // - N+1: NewFrame() // will create floating host window for that node
+ // - N+1: DockSpace(id) // requalify node as dockspace, moving host window
+ if (node->HostWindow && node->HostWindow != host_window && node->HostWindow->DockNodeAsHost == node)
+ node->HostWindow->DockNodeAsHost = NULL;
+
+ host_window->DockNodeAsHost = node;
+ node->HostWindow = host_window;
+}
+
+static void ImGui::DockNodeUpdate(ImGuiDockNode* node)
+{
+ ImGuiContext& g = *GImGui;
+ IM_ASSERT(node->LastFrameActive != g.FrameCount);
+ node->LastFrameAlive = g.FrameCount;
+ node->IsBgDrawnThisFrame = false;
+
+ node->CentralNode = node->OnlyNodeWithWindows = NULL;
+ if (node->IsRootNode())
+ DockNodeUpdateForRootNode(node);
+
+ // Remove tab bar if not needed
+ if (node->TabBar && node->IsNoTabBar())
+ DockNodeRemoveTabBar(node);
+
+ // Early out for hidden root dock nodes (when all DockId references are in inactive windows, or there is only 1 floating window holding on the DockId)
+ bool want_to_hide_host_window = false;
+ if (node->IsFloatingNode())
+ {
+ if (node->Windows.Size <= 1 && node->IsLeafNode())
+ if (!g.IO.ConfigDockingAlwaysTabBar && (node->Windows.Size == 0 || !node->Windows[0]->WindowClass.DockingAlwaysTabBar))
+ 