anulax
/
imgui-docking
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Docking: Internals: Transitioning some code toward consistently using ImGuiContext* ctx parameter instead of ImGuiDockContext

Browse Source
features/sdl_renderer3_multiviewports
omar ago%!(EXTRA string=7 years)
parent 28094b7cea
commit 35032d41fa
3 changed files with 151 additions and 143 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 275
      imgui.cpp
  2. 16
      imgui_internal.h
  3. 3
      imgui_widgets.cpp

275
imgui.cpp
Unescape View File

@ -3351,7 +3351,7 @@ void ImGui::NewFrame()
// Undocking // Undocking
// (needs to be before UpdateMouseMovingWindow so the window is already offset and following the mouse on the detaching frame) // (needs to be before UpdateMouseMovingWindow so the window is already offset and following the mouse on the detaching frame)
DockContextNewFrameUpdateUndocking(g.DockContext); DockContextNewFrameUpdateUndocking(&g);
// Find hovered window // Find hovered window
// (needs to be before UpdateMovingWindow so we fill HoveredWindowUnderMovingWindow on the mouse release frame) // (needs to be before UpdateMovingWindow so we fill HoveredWindowUnderMovingWindow on the mouse release frame)
@ -3406,7 +3406,7 @@ void ImGui::NewFrame()
ClosePopupsOverWindow(g.NavWindow); ClosePopupsOverWindow(g.NavWindow);
// Docking // Docking
DockContextNewFrameUpdateDocking(g.DockContext); DockContextNewFrameUpdateDocking(&g);
// Create implicit window - we will only render it if the user has added something to it. // Create implicit window - we will only render it if the user has added something to it.
// We don't use "Debug" to avoid colliding with user trying to create a "Debug" window with custom flags. // We don't use "Debug" to avoid colliding with user trying to create a "Debug" window with custom flags.
@ -3682,7 +3682,7 @@ void ImGui::EndFrame()
End(); End();
// Docking // Docking
DockContextEndFrame(g.DockContext); DockContextEndFrame(&g);
// Draw modal whitening background on _other_ viewports than the one the modal or target are on // Draw modal whitening background on _other_ viewports than the one the modal or target are on
ImGuiWindow* modal_window = GetFrontMostPopupModal(); ImGuiWindow* modal_window = GetFrontMostPopupModal();
@ -9625,16 +9625,16 @@ struct ImGuiDockContext
namespace ImGui namespace ImGui
{ {
// ImGuiDockContext // ImGuiDockContext
static ImGuiDockNode* DockContextFindNodeByID(ImGuiDockContext* ctx, ImGuiID id); static ImGuiDockNode* DockContextFindNodeByID(ImGuiContext* ctx, ImGuiID id);
static ImGuiDockNode* DockContextAddNode(ImGuiDockContext* ctx, ImGuiID id); static ImGuiDockNode* DockContextAddNode(ImGuiContext* ctx, ImGuiID id);
static void DockContextRemoveNode(ImGuiDockContext* ctx, ImGuiDockNode* node); static void DockContextRemoveNode(ImGuiContext* ctx, ImGuiDockNode* node);
static void DockContextQueueDock(ImGuiDockContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer); static void DockContextQueueDock(ImGuiContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer);
static void DockContextProcessDock(ImGuiDockContext* ctx, ImGuiDockRequest* req); static void DockContextProcessDock(ImGuiContext* ctx, ImGuiDockRequest* req);
static void DockContextProcessUndock(ImGuiDockContext* ctx, ImGuiWindow* window); static void DockContextProcessUndock(ImGuiContext* ctx, ImGuiWindow* window);
static void DockContextGcUnusedSettingsNodes(ImGuiDockContext* ctx); static void DockContextGcUnusedSettingsNodes(ImGuiContext* ctx);
static void DockContextClearNodes(ImGuiDockContext* ctx, ImGuiID root_id, bool clear_persistent_docking_references); // Set root_id==0 to clear all static void DockContextClearNodes(ImGuiContext* ctx, ImGuiID root_id, bool clear_persistent_docking_references); // Set root_id==0 to clear all
static void DockContextBuildNodesFromSettings(ImGuiDockContext* ctx, ImGuiDockNodeSettings* node_settings_array, int node_settings_count); static void DockContextBuildNodesFromSettings(ImGuiContext* ctx, ImGuiDockNodeSettings* node_settings_array, int node_settings_count);
static void DockContextBuildAddWindowsToNodes(ImGuiDockContext* ctx, ImGuiID root_id); // Use root_id==0 to add all static void DockContextBuildAddWindowsToNodes(ImGuiContext* ctx, ImGuiID root_id); // Use root_id==0 to add all
// ImGuiDockNode // ImGuiDockNode
static void DockNodeAddWindow(ImGuiDockNode* node, ImGuiWindow* window); static void DockNodeAddWindow(ImGuiDockNode* node, ImGuiWindow* window);
@ -9658,15 +9658,15 @@ namespace ImGui
static int DockNodeGetTabOrder(ImGuiWindow* window); static int DockNodeGetTabOrder(ImGuiWindow* window);
// ImGuiDockNode tree manipulations // ImGuiDockNode tree manipulations
static void DockNodeTreeSplit(ImGuiDockContext* ctx, ImGuiDockNode* parent_node, ImGuiAxis split_axis, int split_first_child, float split_ratio, ImGuiDockNode* new_node); static void DockNodeTreeSplit(ImGuiContext* ctx, ImGuiDockNode* parent_node, ImGuiAxis split_axis, int split_first_child, float split_ratio, ImGuiDockNode* new_node);
static void DockNodeTreeMerge(ImGuiDockContext* ctx, ImGuiDockNode* parent_node, ImGuiDockNode* merge_lead_child); static void DockNodeTreeMerge(ImGuiContext* ctx, ImGuiDockNode* parent_node, ImGuiDockNode* merge_lead_child);
static void DockNodeTreeUpdatePosSize(ImGuiDockNode* node, ImVec2 pos, ImVec2 size); static void DockNodeTreeUpdatePosSize(ImGuiDockNode* node, ImVec2 pos, ImVec2 size);
static void DockNodeTreeUpdateSplitter(ImGuiDockNode* node); static void DockNodeTreeUpdateSplitter(ImGuiDockNode* node);
static ImGuiDockNode* DockNodeTreeFindNodeByPos(ImGuiDockNode* node, ImVec2 pos); static ImGuiDockNode* DockNodeTreeFindNodeByPos(ImGuiDockNode* node, ImVec2 pos);
// Settings // Settings
static void DockSettingsRemoveReferencesToNodes(ImGuiID* node_ids, int node_ids_count); static void DockSettingsRemoveReferencesToNodes(ImGuiID* node_ids, int node_ids_count);
static ImGuiDockNodeSettings* DockSettingsFindNodeSettings(ImGuiDockContext* ctx, ImGuiID node_id); static ImGuiDockNodeSettings* DockSettingsFindNodeSettings(ImGuiContext* ctx, ImGuiID node_id);
static void* DockSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name); static void* DockSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name);
static void DockSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line); static void DockSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line);
static void DockSettingsHandler_WriteAll(ImGuiContext* imgui_ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf); static void DockSettingsHandler_WriteAll(ImGuiContext* imgui_ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf);
@ -9683,9 +9683,9 @@ namespace ImGui
// This is convenient as docking reconfiguration can be implemented by mostly poking at the simpler setttings data. // This is convenient as docking reconfiguration can be implemented by mostly poking at the simpler setttings data.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ImGui::DockContextInitialize(ImGuiContext* imgui_context) void ImGui::DockContextInitialize(ImGuiContext* ctx)
{ {
ImGuiContext& g = *imgui_context; ImGuiContext& g = *ctx;
IM_ASSERT(g.DockContext == NULL); IM_ASSERT(g.DockContext == NULL);
g.DockContext = IM_NEW(ImGuiDockContext)(); g.DockContext = IM_NEW(ImGuiDockContext)();
@ -9699,43 +9699,44 @@ void ImGui::DockContextInitialize(ImGuiContext* imgui_context)
g.SettingsHandlers.push_back(ini_handler); g.SettingsHandlers.push_back(ini_handler);
} }
void ImGui::DockContextShutdown(ImGuiContext* imgui_context) void ImGui::DockContextShutdown(ImGuiContext* ctx)
{ {
ImGuiContext& g = *imgui_context; ImGuiContext& g = *ctx;
ImGuiDockContext* ctx = g.DockContext; ImGuiDockContext* dc = ctx->DockContext;
for (int n = 0; n < ctx->Nodes.Data.Size; n++) for (int n = 0; n < dc->Nodes.Data.Size; n++)
if (ImGuiDockNode* node = (ImGuiDockNode*)ctx->Nodes.Data[n].val_p) if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
IM_DELETE(node); IM_DELETE(node);
IM_DELETE(g.DockContext); IM_DELETE(g.DockContext);
g.DockContext = NULL; g.DockContext = NULL;
} }
void ImGui::DockContextOnLoadSettings() void ImGui::DockContextOnLoadSettings(ImGuiContext* ctx)
{ {
ImGuiContext& g = *GImGui; ImGuiDockContext* dc = ctx->DockContext;
ImGuiDockContext* ctx = g.DockContext;
DockContextGcUnusedSettingsNodes(ctx); DockContextGcUnusedSettingsNodes(ctx);
DockContextBuildNodesFromSettings(ctx, ctx->SettingsNodes.Data, ctx->SettingsNodes.Size); DockContextBuildNodesFromSettings(ctx, dc->SettingsNodes.Data, dc->SettingsNodes.Size);
} }
// This function also acts as a de-facto test to make sure we can rebuild from scratch without a glitch // This function also acts as a de-facto test to make sure we can rebuild from scratch without a glitch
void ImGui::DockContextRebuild(ImGuiDockContext* ctx) void ImGui::DockContextRebuild(ImGuiContext* ctx)
{ {
//IMGUI_DEBUG_LOG("[docking] full rebuild\n"); //IMGUI_DEBUG_LOG("[docking] full rebuild\n");
ImGuiDockContext* dc = ctx->DockContext;
SaveIniSettingsToMemory(); SaveIniSettingsToMemory();
ImGuiID root_id = 0; // Rebuild all ImGuiID root_id = 0; // Rebuild all
DockContextClearNodes(ctx, root_id, false); DockContextClearNodes(ctx, root_id, false);
DockContextBuildNodesFromSettings(ctx, ctx->SettingsNodes.Data, ctx->SettingsNodes.Size); DockContextBuildNodesFromSettings(ctx, dc->SettingsNodes.Data, dc->SettingsNodes.Size);
DockContextBuildAddWindowsToNodes(ctx, root_id); DockContextBuildAddWindowsToNodes(ctx, root_id);
} }
// Docking context update function, called by NewFrame() // Docking context update function, called by NewFrame()
void ImGui::DockContextNewFrameUpdateUndocking(ImGuiDockContext* ctx) void ImGui::DockContextNewFrameUpdateUndocking(ImGuiContext* ctx)
{ {
ImGuiContext& g = *GImGui; ImGuiContext& g = *ctx;
ImGuiDockContext* dc = ctx->DockContext;
if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable)) if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
{ {
if (ctx->Nodes.Data.Size > 0 || ctx->Requests.Size > 0) if (dc->Nodes.Data.Size > 0 || dc->Requests.Size > 0)
DockContextClearNodes(ctx, 0, true); DockContextClearNodes(ctx, 0, true);
return; return;
} }
@ -9744,51 +9745,52 @@ void ImGui::DockContextNewFrameUpdateUndocking(ImGuiDockContext* ctx)
if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_C))) if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_C)))
ctx->WantFullRebuild = true; ctx->WantFullRebuild = true;
#endif #endif
if (ctx->WantFullRebuild) if (dc->WantFullRebuild)
{ {
DockContextRebuild(ctx); DockContextRebuild(ctx);
ctx->WantFullRebuild = false; dc->WantFullRebuild = false;
} }
// Process Undocking requests (we need to process them _before_ the UpdateMouseMovingWindow call in NewFrame) // Process Undocking requests (we need to process them _before_ the UpdateMouseMovingWindow call in NewFrame)
for (int n = 0; n < ctx->Requests.Size; n++) for (int n = 0; n < dc->Requests.Size; n++)
if (ctx->Requests[n].Type == ImGuiDockRequestType_Undock) if (dc->Requests[n].Type == ImGuiDockRequestType_Undock)
DockContextProcessUndock(ctx, ctx->Requests[n].UndockTarget); DockContextProcessUndock(ctx, dc->Requests[n].UndockTarget);
} }
// Docking context update function, called by NewFrame() // Docking context update function, called by NewFrame()
void ImGui::DockContextNewFrameUpdateDocking(ImGuiDockContext* ctx) void ImGui::DockContextNewFrameUpdateDocking(ImGuiContext* ctx)
{ {
ImGuiContext& g = *GImGui; ImGuiContext& g = *ctx;
ImGuiDockContext* dc = ctx->DockContext;
if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable)) if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
return; return;
// Process Docking requests // Process Docking requests
for (int n = 0; n < ctx->Requests.Size; n++) for (int n = 0; n < dc->Requests.Size; n++)
if (ctx->Requests[n].Type == ImGuiDockRequestType_Dock) if (dc->Requests[n].Type == ImGuiDockRequestType_Dock)
DockContextProcessDock(ctx, &ctx->Requests[n]); DockContextProcessDock(ctx, &dc->Requests[n]);
ctx->Requests.resize(0); dc->Requests.resize(0);
// Create windows for each automatic docking nodes // 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) // 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 < ctx->Nodes.Data.Size; n++) for (int n = 0; n < dc->Nodes.Data.Size; n++)
if (ImGuiDockNode* node = (ImGuiDockNode*)ctx->Nodes.Data[n].val_p) if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
if (!node->IsExplicitRoot && node->IsRootNode()) if (!node->IsExplicitRoot && node->IsRootNode())
DockNodeUpdate(node); DockNodeUpdate(node);
} }
// Docking context update function, called by EndFrame() // Docking context update function, called by EndFrame()
void ImGui::DockContextEndFrame(ImGuiDockContext* ctx) void ImGui::DockContextEndFrame(ImGuiContext* ctx)
{ {
(void)ctx; (void)ctx;
} }
static ImGuiDockNode* ImGui::DockContextFindNodeByID(ImGuiDockContext* ctx, ImGuiID id) static ImGuiDockNode* ImGui::DockContextFindNodeByID(ImGuiContext* ctx, ImGuiID id)
{ {
return (ImGuiDockNode*)ctx->Nodes.GetVoidPtr(id); return (ImGuiDockNode*)ctx->DockContext->Nodes.GetVoidPtr(id);
} }
static ImGuiDockNode* ImGui::DockContextAddNode(ImGuiDockContext* ctx, ImGuiID 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. // 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.
if (id == (ImGuiID)-1) if (id == (ImGuiID)-1)
@ -9801,12 +9803,15 @@ static ImGuiDockNode* ImGui::DockContextAddNode(ImGuiDockContext* ctx, ImGuiID i
IM_ASSERT(DockContextFindNodeByID(ctx, id) == NULL); IM_ASSERT(DockContextFindNodeByID(ctx, id) == NULL);
ImGuiDockNode* node = IM_NEW(ImGuiDockNode)(id); ImGuiDockNode* node = IM_NEW(ImGuiDockNode)(id);
node->InitFromFirstWindow = true; node->InitFromFirstWindow = true;
ctx->Nodes.SetVoidPtr(node->ID, node); ctx->DockContext->Nodes.SetVoidPtr(node->ID, node);
return node; return node;
} }
static void ImGui::DockContextRemoveNode(ImGuiDockContext* ctx, ImGuiDockNode* node) static void ImGui::DockContextRemoveNode(ImGuiContext* ctx, ImGuiDockNode* node)
{ {
ImGuiContext& g = *ctx;
ImGuiDockContext* dc = ctx->DockContext;
//printf("[%05d] RemoveNode 0x%04X\n", node->ID); //printf("[%05d] RemoveNode 0x%04X\n", node->ID);
IM_ASSERT(DockContextFindNodeByID(ctx, node->ID) == node); IM_ASSERT(DockContextFindNodeByID(ctx, node->ID) == node);
IM_ASSERT(node->ChildNodes[0] == NULL && node->ChildNodes[1] == NULL); IM_ASSERT(node->ChildNodes[0] == NULL && node->ChildNodes[1] == NULL);
@ -9819,21 +9824,21 @@ static void ImGui::DockContextRemoveNode(ImGuiDockContext* ctx, ImGuiDockNode* n
{ {
IM_ASSERT(parent_node->ChildNodes[0] == node || parent_node->ChildNodes[1] == node); 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]); ImGuiDockNode* sibling_node = (parent_node->ChildNodes[0] == node ? parent_node->ChildNodes[1] : parent_node->ChildNodes[0]);
DockNodeTreeMerge(ctx, parent_node, sibling_node); DockNodeTreeMerge(&g, parent_node, sibling_node);
} }
else else
{ {
ctx->Nodes.SetVoidPtr(node->ID, NULL); dc->Nodes.SetVoidPtr(node->ID, NULL);
IM_DELETE(node); IM_DELETE(node);
} }
} }
void ImGui::DockContextClearNodes(ImGuiDockContext* ctx, ImGuiID root_id, bool clear_persistent_docking_references) void ImGui::DockContextClearNodes(ImGuiContext* ctx, ImGuiID root_id, bool clear_persistent_docking_references)
{ {
ImGuiContext& g = *ctx;
ImGuiDockContext* dc = ctx->DockContext;
SaveIniSettingsToMemory(NULL); SaveIniSettingsToMemory(NULL);
ImGuiContext& g = *GImGui;
// Clear references in windows // Clear references in windows
for (int n = 0; n < g.Windows.Size; n++) for (int n = 0; n < g.Windows.Size; n++)
{ {
@ -9849,44 +9854,45 @@ void ImGui::DockContextClearNodes(ImGuiDockContext* ctx, ImGuiID root_id, bool c
} }
// Clear nodes // Clear nodes
for (int n = 0; n < ctx->Nodes.Data.Size; n++) for (int n = 0; n < dc->Nodes.Data.Size; n++)
if (ImGuiDockNode* node = (ImGuiDockNode*)ctx->Nodes.Data[n].val_p) if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
{ {
bool want_removal = (root_id == 0 || DockNodeGetRootNode(node)->ID == root_id); bool want_removal = (root_id == 0 || DockNodeGetRootNode(node)->ID == root_id);
if (want_removal) if (want_removal)
{ {
IM_DELETE(node); IM_DELETE(node);
ctx->Nodes.Data[n].val_p = NULL; dc->Nodes.Data[n].val_p = NULL;
} }
} }
if (root_id == 0) if (root_id == 0)
ctx->Nodes.Clear(); dc->Nodes.Clear();
ctx->Requests.clear(); dc->Requests.clear();
} }
static void ImGui::DockContextGcUnusedSettingsNodes(ImGuiDockContext* ctx) static void ImGui::DockContextGcUnusedSettingsNodes(ImGuiContext* ctx)
{ {
ImGuiContext& g = *GImGui; ImGuiContext& g = *ctx;
ImGuiDockContext* dc = ctx->DockContext;
IM_ASSERT(g.Windows.Size == 0); IM_ASSERT(g.Windows.Size == 0);
// Count reference to dock ids from window settings // Count reference to dock ids from window settings
ImGuiStorage ref_count_map; // Map dock_id -> counter ImGuiStorage ref_count_map; // Map dock_id -> counter
ref_count_map.Data.reserve(ctx->SettingsNodes.Size); ref_count_map.Data.reserve(dc->SettingsNodes.Size);
for (int settings_n = 0; settings_n < g.SettingsWindows.Size; settings_n++) for (int settings_n = 0; settings_n < g.SettingsWindows.Size; settings_n++)
if (g.SettingsWindows[settings_n].DockId != 0) if (g.SettingsWindows[settings_n].DockId != 0)
(*ref_count_map.GetIntRef(g.SettingsWindows[settings_n].DockId, 0))++; (*ref_count_map.GetIntRef(g.SettingsWindows[settings_n].DockId, 0))++;
// Mark nodes that are parents // Mark nodes that are parents
ImGuiStorage is_parent_map; ImGuiStorage is_parent_map;
is_parent_map.Data.reserve(ctx->SettingsNodes.Size); is_parent_map.Data.reserve(dc->SettingsNodes.Size);
for (int settings_n = 0; settings_n < ctx->SettingsNodes.Size; settings_n++) for (int settings_n = 0; settings_n < dc->SettingsNodes.Size; settings_n++)
if (ctx->SettingsNodes[settings_n].ParentID) if (dc->SettingsNodes[settings_n].ParentID)
is_parent_map.SetInt(ctx->SettingsNodes[settings_n].ParentID, 1); is_parent_map.SetInt(dc->SettingsNodes[settings_n].ParentID, 1);
// If a root node has only 1 reference in window settings we clear it // If a root node has only 1 reference in window settings we clear it
for (int settings_n = 0; settings_n < ctx->SettingsNodes.Size; settings_n++) for (int settings_n = 0; settings_n < dc->SettingsNodes.Size; settings_n++)
{ {
ImGuiDockNodeSettings* settings = &ctx->SettingsNodes[settings_n]; ImGuiDockNodeSettings* settings = &dc->SettingsNodes[settings_n];
int ref_count = ref_count_map.GetInt(settings->ID, 0); int ref_count = ref_count_map.GetInt(settings->ID, 0);
if (ref_count <= 1) if (ref_count <= 1)
{ {
@ -9902,7 +9908,7 @@ static void ImGui::DockContextGcUnusedSettingsNodes(ImGuiDockContext* ctx)
} }
} }
static void ImGui::DockContextBuildNodesFromSettings(ImGuiDockContext* ctx, ImGuiDockNodeSettings* node_settings_array, int node_settings_count) static void ImGui::DockContextBuildNodesFromSettings(ImGuiContext* ctx, ImGuiDockNodeSettings* node_settings_array, int node_settings_count)
{ {
// Build nodes // Build nodes
for (int node_n = 0; node_n < node_settings_count; node_n++) for (int node_n = 0; node_n < node_settings_count; node_n++)
@ -9926,10 +9932,10 @@ static void ImGui::DockContextBuildNodesFromSettings(ImGuiDockContext* ctx, ImGu
} }
} }
void ImGui::DockContextBuildAddWindowsToNodes(ImGuiDockContext* ctx, ImGuiID root_id) 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) // Rebind all windows to nodes (they can also lazily rebind but we'll have a visible glitch during the first frame)
ImGuiContext& g = *GImGui; ImGuiContext& g = *ctx;
for (int n = 0; n < g.Windows.Size; n++) for (int n = 0; n < g.Windows.Size; n++)
{ {
ImGuiWindow* window = g.Windows[n]; ImGuiWindow* window = g.Windows[n];
@ -9949,7 +9955,7 @@ void ImGui::DockContextBuildAddWindowsToNodes(ImGuiDockContext* ctx, ImGuiID roo
// Docking: ImGuiDockContext Docking/Undocking functions // Docking: ImGuiDockContext Docking/Undocking functions
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ImGui::DockContextQueueDock(ImGuiDockContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer) void ImGui::DockContextQueueDock(ImGuiContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer)
{ {
ImGuiDockRequest req; ImGuiDockRequest req;
req.Type = ImGuiDockRequestType_Dock; req.Type = ImGuiDockRequestType_Dock;
@ -9959,20 +9965,20 @@ void ImGui::DockContextQueueDock(ImGuiDockContext* ctx, ImGuiWindow* target, ImG
req.DockSplitDir = split_dir; req.DockSplitDir = split_dir;
req.DockSplitRatio = split_ratio; req.DockSplitRatio = split_ratio;
req.DockSplitOuter = split_outer; req.DockSplitOuter = split_outer;
ctx->Requests.push_back(req); ctx->DockContext->Requests.push_back(req);
} }
void ImGui::DockContextQueueUndock(ImGuiDockContext* ctx, ImGuiWindow* window) void ImGui::DockContextQueueUndock(ImGuiContext* ctx, ImGuiWindow* window)
{ {
ImGuiDockRequest req; ImGuiDockRequest req;
req.Type = ImGuiDockRequestType_Undock; req.Type = ImGuiDockRequestType_Undock;
req.UndockTarget = window; req.UndockTarget = window;
ctx->Requests.push_back(req); ctx->DockContext->Requests.push_back(req);
} }
void ImGui::DockContextProcessDock(ImGuiDockContext* ctx, ImGuiDockRequest* req) void ImGui::DockContextProcessDock(ImGuiContext* ctx, ImGuiDockRequest* req)
{ {
ImGuiContext& g = *GImGui; ImGuiContext& g = *ctx;
ImGuiWindow* payload_window = req->DockPayload; ImGuiWindow* payload_window = req->DockPayload;
ImGuiWindow* target_window = req->DockTarget; ImGuiWindow* target_window = req->DockTarget;
ImGuiDockNode* target_node = req->DockTargetNode; ImGuiDockNode* target_node = req->DockTargetNode;
@ -10081,10 +10087,9 @@ void ImGui::DockContextProcessDock(ImGuiDockContext* ctx, ImGuiDockRequest* req)
target_node->TabBar->NextSelectedTabId = next_selected_id; target_node->TabBar->NextSelectedTabId = next_selected_id;
} }
void ImGui::DockContextProcessUndock(ImGuiDockContext* ctx, ImGuiWindow* window) void ImGui::DockContextProcessUndock(ImGuiContext* ctx, ImGuiWindow* window)
{ {
(void)ctx; ImGuiContext& g = *ctx;
ImGuiContext& g = *GImGui;
IM_ASSERT(window->LastFrameActive < g.FrameCount); IM_ASSERT(window->LastFrameActive < g.FrameCount);
if (window->DockNode) if (window->DockNode)
DockNodeRemoveWindow(window->DockNode, window, 0); DockNodeRemoveWindow(window->DockNode, window, 0);
@ -10176,7 +10181,6 @@ static void ImGui::DockNodeAddWindow(ImGuiDockNode* node, ImGuiWindow* window)
static void ImGui::DockNodeRemoveWindow(ImGuiDockNode* node, ImGuiWindow* window, ImGuiID save_dock_id) static void ImGui::DockNodeRemoveWindow(ImGuiDockNode* node, ImGuiWindow* window, ImGuiID save_dock_id)
{ {
ImGuiContext& g = *GImGui; ImGuiContext& g = *GImGui;
ImGuiDockContext* ctx = g.DockContext;
IM_ASSERT(window->DockNode == node); IM_ASSERT(window->DockNode == node);
//IM_ASSERT(window->RootWindow == node->HostWindow); //IM_ASSERT(window->RootWindow == node->HostWindow);
//IM_ASSERT(window->LastFrameActive < g.FrameCount); // We may call this from Begin() //IM_ASSERT(window->LastFrameActive < g.FrameCount); // We may call this from Begin()
@ -10192,7 +10196,7 @@ static void ImGui::DockNodeRemoveWindow(ImGuiDockNode* node, ImGuiWindow* window
{ {
// Automatic dock node delete themselves if they are not holding at least one tab // Automatic dock node delete themselves if they are not holding at least one tab
IM_ASSERT(node->Windows[0] == window); IM_ASSERT(node->Windows[0] == window);
DockContextRemoveNode(ctx, node); DockContextRemoveNode(&g, node);
return; return;
} }
@ -11022,9 +11026,9 @@ static void ImGui::DockNodePreviewDockRender(ImGuiWindow* host_window, ImGuiDock
// Docking: ImGuiDockNode Tree manipulation functions // Docking: ImGuiDockNode Tree manipulation functions
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ImGui::DockNodeTreeSplit(ImGuiDockContext* ctx, ImGuiDockNode* parent_node, ImGuiAxis split_axis, int split_inheritor_child_idx, float split_ratio, ImGuiDockNode* new_node) void ImGui::DockNodeTreeSplit(ImGuiContext* ctx, ImGuiDockNode* parent_node, ImGuiAxis split_axis, int split_inheritor_child_idx, float split_ratio, ImGuiDockNode* new_node)
{ {
ImGuiContext& g = *GImGui; ImGuiContext& g = *ctx;
IM_ASSERT(split_axis != ImGuiAxis_None); IM_ASSERT(split_axis != ImGuiAxis_None);
ImGuiDockNode* child_0 = (new_node && split_inheritor_child_idx != 0) ? new_node : DockContextAddNode(ctx, (ImGuiID)-1); ImGuiDockNode* child_0 = (new_node && split_inheritor_child_idx != 0) ? new_node : DockContextAddNode(ctx, (ImGuiID)-1);
@ -11050,7 +11054,7 @@ void ImGui::DockNodeTreeSplit(ImGuiDockContext* ctx, ImGuiDockNode* parent_node,
DockNodeTreeUpdatePosSize(parent_node, parent_node->Pos, parent_node->Size); DockNodeTreeUpdatePosSize(parent_node, parent_node->Pos, parent_node->Size);
} }
void ImGui::DockNodeTreeMerge(ImGuiDockContext* ctx, ImGuiDockNode* parent_node, ImGuiDockNode* merge_lead_child) void ImGui::DockNodeTreeMerge(ImGuiContext* ctx, ImGuiDockNode* parent_node, ImGuiDockNode* merge_lead_child)
{ {
ImGuiDockNode* child_0 = parent_node->ChildNodes[0]; ImGuiDockNode* child_0 = parent_node->ChildNodes[0];
ImGuiDockNode* child_1 = parent_node->ChildNodes[1]; ImGuiDockNode* child_1 = parent_node->ChildNodes[1];
@ -11068,8 +11072,8 @@ void ImGui::DockNodeTreeMerge(ImGuiDockContext* ctx, ImGuiDockNode* parent_node,
parent_node->IsDocumentRoot = child_0->IsDocumentRoot || child_1->IsDocumentRoot; parent_node->IsDocumentRoot = child_0->IsDocumentRoot || child_1->IsDocumentRoot;
parent_node->LastExplicitSize = backup_last_explicit_size; parent_node->LastExplicitSize = backup_last_explicit_size;
ctx->Nodes.SetVoidPtr(child_0->ID, NULL); ctx->DockContext->Nodes.SetVoidPtr(child_0->ID, NULL);
ctx->Nodes.SetVoidPtr(child_1->ID, NULL); ctx->DockContext->Nodes.SetVoidPtr(child_1->ID, NULL);
IM_DELETE(child_0); IM_DELETE(child_0);
IM_DELETE(child_1); IM_DELETE(child_1);
} }
@ -11308,8 +11312,8 @@ void ImGui::SetWindowDock(ImGuiWindow* window, ImGuiID dock_id, ImGuiCond cond)
void ImGui::DockSpace(ImGuiID id, const ImVec2& size_arg, ImGuiDockSpaceFlags dock_space_flags, ImGuiID user_type_filter) void ImGui::DockSpace(ImGuiID id, const ImVec2& size_arg, ImGuiDockSpaceFlags dock_space_flags, ImGuiID user_type_filter)
{ {
ImGuiContext& g = *GImGui; ImGuiContext* ctx = GImGui;
ImGuiDockContext* ctx = g.DockContext; ImGuiContext& g = *ctx;
ImGuiWindow* window = GetCurrentWindow(); ImGuiWindow* window = GetCurrentWindow();
@ -11378,7 +11382,8 @@ void ImGui::DockSpace(ImGuiID id, const ImVec2& size_arg, ImGuiDockSpaceFlags do
void ImGui::BeginDocked(ImGuiWindow* window, bool* p_open) void ImGui::BeginDocked(ImGuiWindow* window, bool* p_open)
{ {
ImGuiContext& g = *GImGui; ImGuiContext* ctx = GImGui;
ImGuiContext& g = *ctx;
// Calling SetNextWindowPos() undock windows by default (by setting PosUndock) // Calling SetNextWindowPos() undock windows by default (by setting PosUndock)
bool want_undock = false; bool want_undock = false;
@ -11387,7 +11392,7 @@ void ImGui::BeginDocked(ImGuiWindow* window, bool* p_open)
g.NextWindowData.PosUndock = false; g.NextWindowData.PosUndock = false;
if (want_undock) if (want_undock)
{ {
DockContextProcessUndock(g.DockContext, window); DockContextProcessUndock(ctx, window);
return; return;
} }
@ -11395,13 +11400,13 @@ void ImGui::BeginDocked(ImGuiWindow* window, bool* p_open)
ImGuiDockNode* dock_node = window->DockNode; ImGuiDockNode* dock_node = window->DockNode;
if (window->DockId != 0 && dock_node == NULL) if (window->DockId != 0 && dock_node == NULL)
{ {
dock_node = DockContextFindNodeByID(g.DockContext, window->DockId); dock_node = DockContextFindNodeByID(ctx, window->DockId);
if (dock_node == NULL) if (dock_node == NULL)
dock_node = DockContextAddNode(g.DockContext, window->DockId); dock_node = DockContextAddNode(ctx, window->DockId);
if (dock_node->IsSplitNode()) if (dock_node->IsSplitNode())
{ {
DockContextProcessUndock(g.DockContext, window); DockContextProcessUndock(ctx, window);
return; return;
} }
@ -11423,7 +11428,7 @@ void ImGui::BeginDocked(ImGuiWindow* window, bool* p_open)
ImGuiDockNode* root_node = DockNodeGetRootNode(dock_node); ImGuiDockNode* root_node = DockNodeGetRootNode(dock_node);
if (root_node->LastFrameAlive < g.FrameCount) if (root_node->LastFrameAlive < g.FrameCount)
{ {
DockContextProcessUndock(g.DockContext, window); DockContextProcessUndock(ctx, window);
} }
else else
{ {
@ -11436,7 +11441,7 @@ void ImGui::BeginDocked(ImGuiWindow* window, bool* p_open)
// Undock if we are submitted earlier than the host window // Undock if we are submitted earlier than the host window
if (dock_node->HostWindow && window->BeginOrderWithinContext < dock_node->HostWindow->BeginOrderWithinContext) if (dock_node->HostWindow && window->BeginOrderWithinContext < dock_node->HostWindow->BeginOrderWithinContext)
{ {
DockContextProcessUndock(g.DockContext, window); DockContextProcessUndock(ctx, window);
return; return;
} }
@ -11506,7 +11511,9 @@ void ImGui::BeginAsDockableDragDropSource(ImGuiWindow* window)
void ImGui::BeginAsDockableDragDropTarget(ImGuiWindow* window) void ImGui::BeginAsDockableDragDropTarget(ImGuiWindow* window)
{ {
ImGuiContext& g = *GImGui; ImGuiContext* ctx = GImGui;
ImGuiContext& g = *ctx;
IM_ASSERT((window->Flags & ImGuiWindowFlags_NoDocking) == 0); IM_ASSERT((window->Flags & ImGuiWindowFlags_NoDocking) == 0);
if (!g.DragDropActive) if (!g.DragDropActive)
return; return;
@ -11557,7 +11564,7 @@ void ImGui::BeginAsDockableDragDropTarget(ImGuiWindow* window)
// Queue docking request // Queue docking request
if (split_data && split_data->IsDropAllowed && payload->IsDelivery()) if (split_data && split_data->IsDropAllowed && payload->IsDelivery())
DockContextQueueDock(g.DockContext, window, split_data->SplitNode, payload_window, split_data->SplitDir, split_data->SplitRatio, split_data == &split_outer); DockContextQueueDock(ctx, window, split_data->SplitNode, payload_window, split_data->SplitDir, split_data->SplitRatio, split_data == &split_outer);
} }
} }
EndDragDropTarget(); EndDragDropTarget();
@ -11587,11 +11594,12 @@ static void ImGui::DockSettingsRemoveReferencesToNodes(ImGuiID* node_ids, int no
} }
} }
static ImGuiDockNodeSettings* ImGui::DockSettingsFindNodeSettings(ImGuiDockContext* ctx, ImGuiID id) static ImGuiDockNodeSettings* ImGui::DockSettingsFindNodeSettings(ImGuiContext* ctx, ImGuiID id)
{ {
for (int n = 0; n < ctx->SettingsNodes.Size; n++) ImGuiDockContext* dc = ctx->DockContext;
if (ctx->SettingsNodes[n].ID == id) for (int n = 0; n < dc->SettingsNodes.Size; n++)
return &ctx->SettingsNodes[n]; if (dc->SettingsNodes[n].ID == id)
return &dc->SettingsNodes[n];
return NULL; return NULL;
} }
@ -11602,7 +11610,7 @@ static void* ImGui::DockSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHan
return (void*)1; return (void*)1;
} }
static void ImGui::DockSettingsHandler_ReadLine(ImGuiContext* imgui_ctx, ImGuiSettingsHandler*, void*, const char* line) static void ImGui::DockSettingsHandler_ReadLine(ImGuiContext* ctx, ImGuiSettingsHandler*, void*, const char* line)
{ {
char c = 0; char c = 0;
int x = 0, y = 0; int x = 0, y = 0;
@ -11632,14 +11640,14 @@ static void ImGui::DockSettingsHandler_ReadLine(ImGuiContext* imgui_ctx, ImGuiSe
if (sscanf(line, " SelectedTab=0x%08X%n", &node.SelectedTabID,&r) == 1) { line += r; } if (sscanf(line, " SelectedTab=0x%08X%n", &node.SelectedTabID,&r) == 1) { line += r; }
//if (node.ParentID == 0 && node.SplitAxis == ImGuiAxis_None) //if (node.ParentID == 0 && node.SplitAxis == ImGuiAxis_None)
// return; // return;
ImGuiDockContext* ctx = imgui_ctx->DockContext; ImGuiDockContext* dc = ctx->DockContext;
if (node.ParentID != 0) if (node.ParentID != 0)
if (ImGuiDockNodeSettings* parent_settings = DockSettingsFindNodeSettings(ctx, node.ParentID)) if (ImGuiDockNodeSettings* parent_settings = DockSettingsFindNodeSettings(ctx, node.ParentID))
node.Depth = parent_settings->Depth + 1; node.Depth = parent_settings->Depth + 1;
ctx->SettingsNodes.push_back(node); dc->SettingsNodes.push_back(node);
} }
static void DockSettingsHandler_DockNodeToSettings(ImGuiDockContext* ctx, ImGuiDockNode* node, int depth) static void DockSettingsHandler_DockNodeToSettings(ImGuiDockContext* dc, ImGuiDockNode* node, int depth)
{ {
ImGuiDockNodeSettings node_settings; ImGuiDockNodeSettings node_settings;
IM_ASSERT(depth < (1 << (sizeof(node_settings.Depth) << 3))); IM_ASSERT(depth < (1 << (sizeof(node_settings.Depth) << 3)));
@ -11653,34 +11661,34 @@ static void DockSettingsHandler_DockNodeToSettings(ImGuiDockContext* ctx, ImGuiD
node_settings.Pos = ImVec2ih((short)node->Pos.x, (short)node->Pos.y); node_settings.Pos = ImVec2ih((short)node->Pos.x, (short)node->Pos.y);
node_settings.Size = ImVec2ih((short)node->Size.x, (short)node->Size.y); node_settings.Size = ImVec2ih((short)node->Size.x, (short)node->Size.y);
node_settings.LastExplicitSize = ImVec2ih((short)node->LastExplicitSize.x, (short)node->LastExplicitSize.y); node_settings.LastExplicitSize = ImVec2ih((short)node->LastExplicitSize.x, (short)node->LastExplicitSize.y);
ctx->SettingsNodes.push_back(node_settings); dc->SettingsNodes.push_back(node_settings);
if (node->ChildNodes[0]) if (node->ChildNodes[0])
DockSettingsHandler_DockNodeToSettings(ctx, node->ChildNodes[0], depth + 1); DockSettingsHandler_DockNodeToSettings(dc, node->ChildNodes[0], depth + 1);
if (node->ChildNodes[1]) if (node->ChildNodes[1])
DockSettingsHandler_DockNodeToSettings(ctx, node->ChildNodes[1], depth + 1); DockSettingsHandler_DockNodeToSettings(dc, node->ChildNodes[1], depth + 1);
} }
static void ImGui::DockSettingsHandler_WriteAll(ImGuiContext* imgui_ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf) static void ImGui::DockSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf)
{ {
// Gather settings data // Gather settings data
// (unlike our windows settings, because nodes are always built we can do a full rewrite of the SettingsNode buffer) // (unlike our windows settings, because nodes are always built we can do a full rewrite of the SettingsNode buffer)
ImGuiDockContext* ctx = imgui_ctx->DockContext; ImGuiDockContext* dc = ctx->DockContext;
ctx->SettingsNodes.resize(0); dc->SettingsNodes.resize(0);
ctx->SettingsNodes.reserve(ctx->Nodes.Data.Size); dc->SettingsNodes.reserve(dc->Nodes.Data.Size);
for (int n = 0; n < ctx->Nodes.Data.Size; n++) for (int n = 0; n < dc->Nodes.Data.Size; n++)
if (ImGuiDockNode* node = (ImGuiDockNode*)ctx->Nodes.Data[n].val_p) if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
if (node->IsRootNode()) if (node->IsRootNode())
DockSettingsHandler_DockNodeToSettings(ctx, node, 0); DockSettingsHandler_DockNodeToSettings(dc, node, 0);
int max_depth = 0; int max_depth = 0;
for (int node_n = 0; node_n < ctx->SettingsNodes.Size; node_n++) for (int node_n = 0; node_n < dc->SettingsNodes.Size; node_n++)
max_depth = ImMax((int)ctx->SettingsNodes[node_n].Depth, max_depth); max_depth = ImMax((int)dc->SettingsNodes[node_n].Depth, max_depth);
// Write to text buffer // Write to text buffer
buf->appendf("[%s][Data]\n", handler->TypeName); buf->appendf("[%s][Data]\n", handler->TypeName);
for (int node_n = 0; node_n < ctx->SettingsNodes.Size; node_n++) for (int node_n = 0; node_n < dc->SettingsNodes.Size; node_n++)
{ {
const ImGuiDockNodeSettings* node_settings = &ctx->SettingsNodes[node_n]; const ImGuiDockNodeSettings* node_settings = &dc->SettingsNodes[node_n];
buf->appendf("%*sDockNode%*s", node_settings->Depth * 2, "", (max_depth - node_settings->Depth) * 2, ""); // Text align nodes to facilitate looking at .ini file buf->appendf("%*sDockNode%*s", node_settings->Depth * 2, "", (max_depth - node_settings->Depth) * 2, ""); // Text align nodes to facilitate looking at .ini file
buf->appendf(" ID=0x%08X", node_settings->ID); buf->appendf(" ID=0x%08X", node_settings->ID);
if (node_settings->ParentID) if (node_settings->ParentID)
@ -12008,7 +12016,7 @@ void ImGui::LoadIniSettingsFromMemory(const char* ini_data, size_t ini_size)
} }
ImGui::MemFree(buf); ImGui::MemFree(buf);
g.SettingsLoaded = true; g.SettingsLoaded = true;
DockContextOnLoadSettings(); DockContextOnLoadSettings(&g);
} }
void ImGui::SaveIniSettingsToDisk(const char* ini_filename) void ImGui::SaveIniSettingsToDisk(const char* ini_filename)
@ -12521,8 +12529,9 @@ void ImGui::ShowMetricsWindow(bool* p_open)
void ImGui::ShowDockingDebug() void ImGui::ShowDockingDebug()
{ {
ImGuiContext& g = *GImGui; ImGuiContext* ctx = GImGui;
ImGuiDockContext* ctx = g.DockContext; ImGuiContext& g = *ctx;
ImGuiDockContext* dc = ctx->DockContext;
struct Funcs struct Funcs
{ {
@ -12589,11 +12598,11 @@ void ImGui::ShowDockingDebug()
if (ImGui::TreeNode("Dock nodes")) if (ImGui::TreeNode("Dock nodes"))
{ {
if (ImGui::SmallButton("Clear settings")) { DockContextClearNodes(ctx, 0, true); } if (ImGui::SmallButton("Clear settings")) { DockContextClearNodes(&g, 0, true); }
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::SmallButton("Rebuild all")) { ctx->WantFullRebuild = true; } if (ImGui::SmallButton("Rebuild all")) { dc->WantFullRebuild = true; }
for (int n = 0; n < ctx->Nodes.Data.Size; n++) for (int n = 0; n < dc->Nodes.Data.Size; n++)
if (ImGuiDockNode* node = (ImGuiDockNode*)ctx->Nodes.Data[n].val_p) if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
if (node->IsRootNode()) if (node->IsRootNode())
Funcs::NodeDockNode(node, "Node"); Funcs::NodeDockNode(node, "Node");
ImGui::TreePop(); ImGui::TreePop();
@ -12620,9 +12629,9 @@ void ImGui::ShowDockingDebug()
ImGui::BulletText("Window '%s' -> DockId %08X", g.SettingsWindows[n].Name, g.SettingsWindows[n].DockId); ImGui::BulletText("Window '%s' -> DockId %08X", g.SettingsWindows[n].Name, g.SettingsWindows[n].DockId);
ImGui::Separator(); ImGui::Separator();
ImGui::Text("Dock Nodes:"); ImGui::Text("Dock Nodes:");
for (int n = 0; n < ctx->SettingsNodes.Size; n++) for (int n = 0; n < dc->SettingsNodes.Size; n++)
{ {
ImGuiDockNodeSettings* settings = &ctx->SettingsNodes[n]; ImGuiDockNodeSettings* settings = &dc->SettingsNodes[n];
const char* selected_tab_name = NULL; const char* selected_tab_name = NULL;
if (settings->SelectedTabID) if (settings->SelectedTabID)
{ {
@ -12638,8 +12647,8 @@ void ImGui::ShowDockingDebug()
if (g.IO.KeyCtrl && show_window_dock_info) if (g.IO.KeyCtrl && show_window_dock_info)
{ {
for (int n = 0; n < ctx->Nodes.Data.Size; n++) for (int n = 0; n < dc->Nodes.Data.Size; n++)
if (ImGuiDockNode* node = (ImGuiDockNode*)ctx->Nodes.Data[n].val_p) if (ImGuiDockNode* node = (ImGuiDockNode*)dc->Nodes.Data[n].val_p)
{ {
ImGuiDockNode* root_node = DockNodeGetRootNode(node); ImGuiDockNode* root_node = DockNodeGetRootNode(node);
if (ImGuiDockNode* hovered_node = DockNodeTreeFindNodeByPos(root_node, g.IO.MousePos)) if (ImGuiDockNode* hovered_node = DockNodeTreeFindNodeByPos(root_node, g.IO.MousePos))

16
imgui_internal.h
Unescape View File

@ -1460,14 +1460,14 @@ namespace ImGui
inline bool IsNavInputPressedAnyOfTwo(ImGuiNavInput n1, ImGuiNavInput n2, ImGuiInputReadMode mode) { return (GetNavInputAmount(n1, mode) + GetNavInputAmount(n2, mode)) > 0.0f; } inline bool IsNavInputPressedAnyOfTwo(ImGuiNavInput n1, ImGuiNavInput n2, ImGuiInputReadMode mode) { return (GetNavInputAmount(n1, mode) + GetNavInputAmount(n2, mode)) > 0.0f; }
// Docking // Docking
IMGUI_API void DockContextInitialize(ImGuiContext* imgui_context); IMGUI_API void DockContextInitialize(ImGuiContext* ctx);
IMGUI_API void DockContextShutdown(ImGuiContext* imgui_context); IMGUI_API void DockContextShutdown(ImGuiContext* ctx);
IMGUI_API void DockContextOnLoadSettings(); IMGUI_API void DockContextOnLoadSettings(ImGuiContext* ctx);
IMGUI_API void DockContextRebuild(ImGuiDockContext* ctx); IMGUI_API void DockContextRebuild(ImGuiContext* ctx);
IMGUI_API void DockContextNewFrameUpdateUndocking(ImGuiDockContext* ctx); IMGUI_API void DockContextNewFrameUpdateUndocking(ImGuiContext* ctx);
IMGUI_API void DockContextNewFrameUpdateDocking(ImGuiDockContext* ctx); IMGUI_API void DockContextNewFrameUpdateDocking(ImGuiContext* ctx);
IMGUI_API void DockContextEndFrame(ImGuiDockContext* ctx); IMGUI_API void DockContextEndFrame(ImGuiContext* ctx);
IMGUI_API void DockContextQueueUndock(ImGuiDockContext* ctx, ImGuiWindow* window); IMGUI_API void DockContextQueueUndock(ImGuiContext* ctx, ImGuiWindow* window);
IMGUI_API void BeginDocked(ImGuiWindow* window, bool* p_open); IMGUI_API void BeginDocked(ImGuiWindow* window, bool* p_open);
IMGUI_API void BeginAsDockableDragDropSource(ImGuiWindow* window); IMGUI_API void BeginAsDockableDragDropSource(ImGuiWindow* window);
IMGUI_API void BeginAsDockableDragDropTarget(ImGuiWindow* window); IMGUI_API void BeginAsDockableDragDropTarget(ImGuiWindow* window);

3
imgui_widgets.cpp
Unescape View File

@ -6455,8 +6455,7 @@ bool ImGui::TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open,
// Undock // Undock
if (undocking_tab && g.ActiveId == id && IsMouseDragging()) if (undocking_tab && g.ActiveId == id && IsMouseDragging())
{ {
ImGuiDockContext* ctx = g.DockContext; DockContextQueueUndock(&g, docked_window);
DockContextQueueUndock(ctx, docked_window);
g.MovingWindow = docked_window; g.MovingWindow = docked_window;
g.ActiveId = g.MovingWindow->MoveId; g.ActiveId = g.MovingWindow->MoveId;
g.ActiveIdClickOffset -= g.MovingWindow->Pos - bb.Min; g.ActiveIdClickOffset -= g.MovingWindow->Pos - bb.Min;

Write Preview
Loading…
Cancel
Save