Docking: crash in UpdateMouseWheel just after loading new docked window layout

[dfeneyrou]

Version/Branch of Dear ImGui:

Version: v1.84 WIP (current top of tree hash a11f368)
Branch: docking
Back-end: independant

My Issue/Question:

I got a ImGui crash when using the mouse wheel in the first frame of a newly created window.
The stack trace is (only 0->2 matter for ImGui library):

[PALANTEER] signal 11 'Segmentation fault' received
  #0  0x7F79AFB1983C : (null)
  #1  imgui.cpp(3895) : ImGui::UpdateMouseWheel()
  #2  imgui.cpp(4185) : ImGui::NewFrame()
  #3  vwPlatform.cpp(484) : vwPlatform::redraw()
  #4  vwPlatform.cpp(404) : vwPlatform::run()
  #5  vwPlatform.cpp(279) : bsBootstrap(int, char**)
  #6  bsOsLinux.cpp(813) : main

The (obvious) following 1 line patch (the line where the crash occurs) fixes the issue:

 imgui.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/imgui.cpp b/imgui.cpp
index ebd2d104..5136c9f5 100644
--- a/imgui.cpp
+++ b/imgui.cpp
@@ -3905,7 +3905,7 @@ void ImGui::UpdateMouseWheel()
     if (wheel_y != 0.0f)
     {
         StartLockWheelingWindow(window);
-        while ((window->Flags & ImGuiWindowFlags_ChildWindow) && ((window->ScrollMax.y == 0.0f) || ((window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))))
+        while ((window->Flags & ImGuiWindowFlags_ChildWindow) && ((window->ScrollMax.y == 0.0f) || ((window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))) && window->ParentWindow)
             window = window->ParentWindow;
         if (!(window->Flags & ImGuiWindowFlags_NoScrollWithMouse) && !(window->Flags & ImGuiWindowFlags_NoMouseInputs))
         {

[ocornut]

Hello,

Thanks for the report.

I am currently unable to reproduce the bug (I tried feeding dummy io.MouseWheel inputs every frame).
Would you have more information? Can you easily reproduce the bug? What are the details of the window which has a NULL window for ParentWindow ? Is that a window you created yourself, or a window created by the docking system?

I would need to understand this in more details as I don't think the fix here is adequate, it may only bury a bug that will reappear somewhere else.
The intent of the codebase is that when ImGuiWindowFlags_ChildWindow is set, window->ParentWindow should always be set as well.

This is reflected by Begin() doing:

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));
...
if (first_begin_of_the_frame)
    UpdateWindowParentAndRootLinks(window, flags, parent_window);

When appending to a window first_begin_of_the_frame == false flags are pulled from write Begin() so right now I am confused about what can lead to this bug.

[dfeneyrou]

I will try to isolate the issue and provide a minimal example (I faced it in a bigger project).

In the frame before (or current, I do not checked precisely), a call to ImGui::LoadIniSettingsFromMemory() was done (template layout re-applied). Maybe this is part of the required context?

[dfeneyrou]

The minimal example below based on example_glfw_opengl3/Linux reproduces the issue.
As it uses docking helpers, imgui_internal.h needs to be included.

It mimics a "full screen" feature: hitting space toggles the current window to take all the space on screen, hidding the others.
By hitting space while playing with the mouse wheel, the crash happens within few seconds.

    int  uniqueIdFullScreen     = -1;  // Current full screen state, either the ID of the full screen window, either -1
    int  nextUniqueIdFullScreen = -2;  // -2: idle  -1: switch to normal  >=0: full screen on this window ID
    char savedLayout[8192] = {0};      // Enough for this example

    // Main loop
    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();

        // Full screen layout management: save and restore ImGui dockspaces (before NewFrame())
        bool doEnterFullScreen = false;
        if(nextUniqueIdFullScreen>=-1) {
            // Fullscreen to normal
            if(uniqueIdFullScreen>=0) {
                uniqueIdFullScreen = -1;
                ImGui::LoadIniSettingsFromMemory(savedLayout, strlen(savedLayout));  // Note: No crash if no reload
            }
            // Normal to fullscreen
            else if(nextUniqueIdFullScreen>=0) {
                uniqueIdFullScreen = nextUniqueIdFullScreen;
                const char* newLayout = ImGui::SaveIniSettingsToMemory();
                IM_ASSERT(strlen(newLayout)<sizeof(savedLayout));
                memcpy(savedLayout, newLayout, strlen(newLayout)+1);
                doEnterFullScreen = true;
            }
            // Reset the automata
            nextUniqueIdFullScreen = -2;
        }

        ImGui::NewFrame();

        // Main "application" window
        ImGui::SetNextWindowSize(io.DisplaySize);
        ImGui::SetNextWindowPos(ImVec2(0, 0));
        ImGui::Begin("App window", NULL, ImGuiWindowFlags_NoDocking);  // Note: No crash if flag is set to 0

        // Docking
        ImGuiID mainDockspaceId = ImGui::GetID("MainDockSpace");
        if(!ImGui::DockBuilderGetNode(mainDockspaceId)) {
            ImGui::DockBuilderAddNode(mainDockspaceId, ImGuiDockNodeFlags_DockSpace); // Add root node
            ImGui::DockSpace(mainDockspaceId, ImVec2(0., 0.), ImGuiDockNodeFlags_PassthruCentralNode);
            ImGui::DockBuilderSetNodeSize(mainDockspaceId, ImGui::GetIO().DisplaySize);
        }
        else if(doEnterFullScreen) {
            // Create the "full screen" layout
            ImGui::DockBuilderRemoveNodeChildNodes(mainDockspaceId); // Remove root and all children
            ImGui::DockSpace(mainDockspaceId, ImVec2(0., 0.), ImGuiDockNodeFlags_PassthruCentralNode);
            ImGui::DockBuilderSetNodeSize(mainDockspaceId, ImGui::GetIO().DisplaySize);
        }
        else {
            // Case no change
            ImGui::DockSpace(mainDockspaceId, ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_PassthruCentralNode);
        }

        // Windows with content
        constexpr int WINDOW_QTY = 1;  // Note: Crash is reproduced with 1 window (but the "fullscreen" feature has a meaning for more)
        char tmpStr[128];
        for(int wId=0; wId<WINDOW_QTY; ++wId) {
            if(uniqueIdFullScreen>=0 && uniqueIdFullScreen!=wId) continue;

            // Create the window
            snprintf(tmpStr, sizeof(tmpStr), "Window %d", wId);
            ImGui::SetNextWindowDockID(mainDockspaceId, ImGuiCond_Once);
            ImGui::Begin(tmpStr, NULL, ImGuiWindowFlags_NoScrollWithMouse);

            // Toggle fullscreen by hitting space. Crash is reproduced by simultaneously hitting space with mouse wheel
            if(ImGui::IsWindowHovered() && ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Space))) {
                nextUniqueIdFullScreen = wId;
            }

            ImGui::End();
        }

        // End of application window
        ImGui::End();

        // Rendering
        (... code from example ...)

        glfwSwapBuffers(window);
     }

[dfeneyrou]

example_glfw_opengl3_main.zip

Easier to reproduce with replacing the example_glfw_opengl3/main.cc with this file (minimum changes). Sorry not to have done that before...

[ocornut]

Thanks, I have managed to reproduce it now.

Reading your initial message I had omitted an important point which explains why I couldn't repro.

The message body said:
"I got a ImGui crash when using the mouse wheel in the first frame of a newly created window."
While issue subject said:
"... just after loading new docked window layout"

I went for what the message body said not realized the subject said something else (which was key to it).

[ocornut]

Pushed fix 58f5092 :)

[ocornut]

Reopening as this caused another issue.