Un docked modal popup window text input via enter causes all inputs in all windows to be click == return.

[Cazadorro]

System Info

Dear ImGui 1.82 WIP (18101)
--------------------------------
sizeof(size_t): 8, sizeof(ImDrawIdx): 2, sizeof(ImDrawVert): 20
define: __cplusplus=201703
define: __linux__
define: __GNUC__=8
define: IMGUI_HAS_VIEWPORT
define: IMGUI_HAS_DOCK
--------------------------------
io.BackendPlatformName: imgui_impl_glfw
io.BackendRendererName: imgui_impl_opengl3
io.ConfigFlags: 0x00000440
 DockingEnable
 ViewportsEnable
io.ConfigViewportsNoDecoration
io.ConfigInputTextCursorBlink
io.ConfigWindowsResizeFromEdges
io.ConfigMemoryCompactTimer = 60.0
io.BackendFlags: 0x00001C0E
 HasMouseCursors
 HasSetMousePos
 PlatformHasViewports
 HasMouseHoveredViewport
 RendererHasVtxOffset
 RendererHasViewports
--------------------------------
io.Fonts: 1 fonts, Flags: 0x00000000, TexSize: 512,64
io.DisplaySize: 1280.00,720.00
io.DisplayFramebufferScale: 1.00,1.00
--------------------------------
style.WindowPadding: 8.00,8.00
style.WindowBorderSize: 1.00
style.FramePadding: 4.00,3.00
style.FrameRounding: 0.00
style.FrameBorderSize: 0.00
style.ItemSpacing: 8.00,4.00
style.ItemInnerSpacing: 4.00,4.00

I'm using OpenGL 4.5 on Centos 7

My Issue/Question:

When undocking a modal window, using input text with the flag ImGuiInputTextFlags_EnterReturnsTrue appears to set every input to "click = return" even on re-creating the modal popup window (so this appears to effect every window). This behavior does not present itself if one instead uses a button to initiate a window close. This behaviors does not present itself when the window is docked in the main window.

Screenshots/Video

Vg8M9KL.-.Imgur.mp4

shows even the other window has click = return after the initial enter

TestSave2-2021-02-24_16.04.39.mp4

Standalone, minimal, complete and verifiable example: (see #2261)

This should be able to reproduce the issue, hypothetically only stuff within draw_ui is relevant, but only depends on ImGUI, glad, glfw3 and a c++17 compatible compiler:

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <imgui.h>
#include <imgui_impl_glfw.h>
#include <imgui_impl_opengl3.h>
#include <imgui_internal.h>
#include <misc/cpp/imgui_stdlib.h>


#include <iostream>
#include <optional>
#include <filesystem>

class TestContext{
public:
    void draw_ui(bool* p_open);
private:
    std::filesystem::path m_file_path;
    void MenuBar();
};

void sub_ui(){
    static double range_min;
    static double range_max;
    static double k;
    static int size;
    ImGui::Text("DetectorInfo:"
                "\n\t          range_a: [min %f, max %f]"
                "\n\t            k: [%f]"
                "\n\t       size: [width %i x height %i]"
            ,
                range_min,
                range_max,
                k,
                size,
                size
    );
    float min = range_min;
    float max = range_max;
    if(ImGui::DragFloatRange2("range",
                               &min,
                               &max,
                               1.0f, 0.0f, 0.0f,
                               "Min: %.1fpx", "Max: %.1fpx",
                               ImGuiSliderFlags_AlwaysClamp)){
        range_min = min;
        range_max = max;
    }

    if (ImGui::InputDouble("k", &k)) {
        k = std::max(k, 0.0);
    }
}

void TestContext::draw_ui(bool *p_open) {
    ImGuiWindowFlags window_flags =
            ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
    if (true) {
        ImGuiViewport *viewport = ImGui::GetMainViewport();
        ImGui::SetNextWindowPos(viewport->Pos);
        ImGui::SetNextWindowSize(viewport->Size);
        ImGui::SetNextWindowViewport(viewport->ID);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        window_flags |=
                ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
                ImGuiWindowFlags_NoMove;
        window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus |
                        ImGuiWindowFlags_NoNavFocus;
    }
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
    auto ret_val = ImGui::Begin("Test Window", p_open, window_flags);
    ImGui::PopStyleVar();
    if(ret_val){
        MenuBar();
        sub_ui();
        ImGui::PopStyleVar(2);
        ImGui::End();
    }
}

void TestContext::MenuBar() {

    static bool open_popup = false;
    if (ImGui::BeginMainMenuBar()) {

        static bool dark_mode = true;
        if (ImGui::BeginMenu("Menu")) {
            if (ImGui::MenuItem("Open Popup")) {
                open_popup = true;
            }
            ImGui::EndMenu();
        }

        ImGui::EndMainMenuBar();
    }
    if (open_popup) {
        ImGui::OpenPopup("TEST Selection");
    }

    if (ImGui::BeginPopupModal("TEST Selection")) {

        if (ImGui::Button("Cancel")) {
            ImGui::CloseCurrentPopup();
            open_popup = false;
            m_file_path = "test";
        }
        static std::string text;
        ImGui::Text("file");
        ImGui::SameLine();
        ImGui::PushItemWidth(-175);
        if (ImGui::InputText("##file_123", &text,
                             ImGuiInputTextFlags_EnterReturnsTrue)) {
            ImGui::CloseCurrentPopup();
            open_popup = false;
            m_file_path = text;
        }
        ImGui::SameLine();
        if (ImGui::Button("Other")) {
            ImGui::CloseCurrentPopup();
            open_popup = false;
            m_file_path = "test";
        }

        ImGui::EndPopup();
    }
}



const char *glsl_version = "#version 450";

void setup_gl() {
    if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)) {
        throw std::runtime_error("Failed to initialize GLAD");
    }
    glFrontFace(GL_CCW);
//    glEnable(GL_CULL_FACE);     // Cull back facing polygons
    glCullFace(GL_BACK);
}

void application() {
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

    GLFWwindow* window = glfwCreateWindow(1280, 720, "Dear ImGui GLFW+OpenGL3 example", NULL, NULL);
    if (window == NULL) {
        return;
    }
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);
    setup_gl();

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO &io = ImGui::GetIO();
    (void) io;
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
#ifdef IMGUI_DEBUG_LOG_DOCKING
    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;           // Enable Docking
    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
#endif
    // Setup Dear ImGui style
    ImGui::StyleColorsDark();
    //ImGui::StyleColorsClassic();

    // Setup Platform/Renderer backends
    ImGui_ImplGlfw_InitForOpenGL(window, true);
    ImGui_ImplOpenGL3_Init(glsl_version);

    // Our state
    ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

    bool open = true;
    TestContext test_context;

    while (!glfwWindowShouldClose(window)) {

        glfwPollEvents();

        // Start the Dear ImGui frame
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();
        ImGui::ShowDemoWindow();
        test_context.draw_ui(&open);

        // Rendering
        ImGui::Render();
        int display_w, display_h;
        glfwGetFramebufferSize(window, &display_w, &display_h);
        glViewport(0, 0, display_w, display_h);
        glClearColor(clear_color.x, clear_color.y, clear_color.z,
                     clear_color.w);
        glClear(GL_COLOR_BUFFER_BIT);
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
            GLFWwindow *backup_current_context = glfwGetCurrentContext();
            ImGui::UpdatePlatformWindows();
            ImGui::RenderPlatformWindowsDefault();
            glfwMakeContextCurrent(backup_current_context);
        }
        glfwSwapBuffers(window);
    }

    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();
    glfwDestroyWindow(window);
}


int main() {
    glfwSetErrorCallback([](int error_code, const char *description) {
        std::cout << "GLFW Error " << error_code << ": "
                  << description << "\n";
    });

    int inited = glfwInit();
    if (!inited) {
        std::cout << "Couldn't init glfw" << std::endl;
        return 1;
    }
    application();
    glfwTerminate();
    return 0;
}

[rokups]

I am unable to reproduce the issue. Could you trim your sample code down so it is actually minimal? Something we could paste into existing sample and get going, something that does not depend on details from graphics APIs. Also please try SDL backend.

[Cazadorro]

@rokups I'm confused by what you mean by "details from graphics APIs" These "details" are ripped straight from the examples of the repo, are you saying those are some how not minimal? The only "graphics API details" are those found in here:

https://github.com/ocornut/imgui/blob/master/examples/example_glfw_opengl3/main.cpp

and in fact, I trimmed those down even more to make it easier to run, I only included that for complete-ness sake. And to a non contributor, Dear ImGUI is a black box so to speak, there's no reason for me not to believe that the particular backend I chose is not relevant to this behavior. Even then, I mentioned in my post

"hypothetically only stuff within draw_ui is relevant".

This is apparently 114 lines of code, I could reduce it, but you're not gaining much:

class TestContext{
public:
    void draw_ui(bool* p_open);
private:
    std::filesystem::path m_file_path;
    void MenuBar();
};

void sub_ui(){
    static double k;
    if (ImGui::InputDouble("k", &k)) {
        k = std::max(k, 0.0);
    }
}

void TestContext::draw_ui(bool *p_open) {
    ImGuiWindowFlags window_flags =
            ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
    if (true) {
        ImGuiViewport *viewport = ImGui::GetMainViewport();
        ImGui::SetNextWindowPos(viewport->Pos);
        ImGui::SetNextWindowSize(viewport->Size);
        ImGui::SetNextWindowViewport(viewport->ID);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        window_flags |=
                ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
                ImGuiWindowFlags_NoMove;
        window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus |
                        ImGuiWindowFlags_NoNavFocus;
    }
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
    auto ret_val = ImGui::Begin("Test Window", p_open, window_flags);
    ImGui::PopStyleVar();
    if(ret_val){
        MenuBar();
        sub_ui();
        ImGui::PopStyleVar(2);
        ImGui::End();
    }
}

void TestContext::MenuBar() {

    static bool open_popup = false;
    if (ImGui::BeginMainMenuBar()) {

        static bool dark_mode = true;
        if (ImGui::BeginMenu("Menu")) {
            if (ImGui::MenuItem("Open Popup")) {
                open_popup = true;
            }
            ImGui::EndMenu();
        }

        ImGui::EndMainMenuBar();
    }
    if (open_popup) {
        ImGui::OpenPopup("TEST Selection");
    }

    if (ImGui::BeginPopupModal("TEST Selection")) {
        static std::string text;
        ImGui::Text("file");
        ImGui::SameLine();
        ImGui::PushItemWidth(-175);
        if (ImGui::InputText("##file_123", &text,
                             ImGuiInputTextFlags_EnterReturnsTrue)) {
            ImGui::CloseCurrentPopup();
            open_popup = false;
            m_file_path = text;
        }
        ImGui::EndPopup();
    }
}

and you loose the ability to verify visually and test buttons, hence why those were included.

That being said, I'm not sure how people are supposed to run this with out the appropriate backend, removing said code would stop people from running the example as is. That's also not a minimal complete example.

Also are you asking me to see if this is still an issue with SDL or are you asking me to switch to SDL? if it is the latter, no that's not an acceptable option, if it is the former, I may not be able to do that with my environment, but I'll try.

[rokups]

@rokups I'm confused by what you mean by "details from graphics APIs"

Sorry, i used a wrong word. I really meant. Backend APIs. It is very likely anything related to glfw/opengl is just unrelated noise that makes it harder to reproduce an issue.

Also are you asking me to see if this is still an issue with SDL or are you asking me to switch to SDL?

I was merely asking to try SDL backend. I would myself, but i am unable to reproduce the issue.

Sample code is still rather big. I assume it should be enough to have couple inputs, a popup and maybe a button to reproduce the issue? Also a textual list of steps to follow to reproduce the issue would be very useful. I tried my best to follow these two videos, but i was unable to reproduce this behavior.

Hopefully a combination of tiny code sample and a list of steps would help us reproduce the issue, which then will lead to a fix.

[ocornut]

Thanks for your effort trimming the code!
Some thoughts:

(1)
One way to clarify if this is back-end related (e.g. a stuck Return key) would be to open the Metrics/Debugger window and inspect some of the data there. Also the Demo -> Inputs sections shows all pressed keys and mouse buttons. If you leave that open in your app that could be helpful.

there's no reason for me not to believe that the particular backend I chose is not relevant to this behavior

You are right, but interestingly making the repro as thin as possible (removing the backend dependency and turning it into a pastable-in-any-imgui-app contained chunk of code) can actually be able to prove or disprove that it is or isn't backend related, and help narrow down the cause of the issue. But checking demo/metrics as mentioned above is an easier first step.

That statement:

This behaviors does not present itself when the window is docked in the main window.
Seems like clue that it could be a stuck key? e.g. the Return Key Up event not received. What happens if you press Return again after?
(Note that issue doesn't appear related to docking at all, but rather to multi-viewports.)

(2)
Note that your report "click == return" statement uses terminology that is biased toward one specific assumption. While I don't know what the issue is, it might be e.g. that something keeps stealing the ActiveID away from the InputText and it's not key related.

(3)
A cursory glance at your code (which I haven't ran but only looked at) suggests that you keep reopening the popup: every frame:

    static bool open_popup = false;
[...]
            if (ImGui::MenuItem("Open Popup")) {
                open_popup = true;
[...]
    if (open_popup) {
        ImGui::OpenPopup("TEST Selection");

In the code likely as presented, I do not think this is related to your issue but still misleading/incorrect, you only want to open the popup once, so removing that static would help. In your own code a slightly different arrangement of code could accidentally trigger a reopening of the popup at the wrong time, stealing focus away from the input text.

[Cazadorro]

@ocornut I did what you said, and indeed, this image shows it does appear to be some sort of event related issue instead of a flag set, here is the video:

TestSaveNext1-2021-03-03_11.15.05.mp4

For some reason, it looks like my key is infinitely being activated (which is not actually the case, my physical keyboard is fine, I can use it outside the context of imgui while it is doing this and nothing is broken, additionally other applications work fine). When I press enter on the field, it fixes the behavior, but I can revert it just as quickly by following the same steps again. I updated GLFW just incase, and it still appears to be an issue.

Again, I demonstrate in the video that if the popup is docked, there is no issue, this held down key issue doesn't happen.

steps to reproduce:

• run example
• click Menu
• click Open popup
• hit enter in field
• attempt to select any field on main gui (it will act as if enter is held down, it isn't)

A cursory glance at your code (which I haven't ran but only looked at) suggests that you keep reopening the popup: every frame:

I only did that because apparently opening popups directly is apparently broken inside menus, and this was the solution of the an issuer somewhere here. It doesn't make logical sense but neither does modal popups not working inside of menus, so at that point the reasoning for why things like that are done goes out the window, the issue is a black box to me, and so is the specific incantation of the solution. As far as I know there is no demo example of menu modal popups.

Do you want me to change the OP code example with this change?

[Cazadorro]

@ocornut @rokups This behavior is specific to GLFW, see here, I do not encounter this in SDL

TestSaveNext2-2021-03-03_12.00.07.mp4

[rokups]

You are right. This issue manifests because pressing enter key triggers a destruction of popup window and it's viewport at the end of current frame. This is problematic because by the time we poll events at the start of next frame - window is already gone and it can not receive key-release event. Fixing issue at it's core may not be trivial, but you may use patch linked above ☝🏻 as a temporary workaround.

[ocornut]

I have now merged the fixproposed by @rokups, I believe it is the best solution.

Was tempted to propose to GLFW that they send those events before window destruction, but it may leads unprepared applications to crash.... So in fact I think that "workaround" is really the best fix.