Same-frame docking layout evaluation

[ssh4net]

Version/Branch of Dear ImGui:

Version 1.92.4, Branch: docking

Back-ends:

imgui_impl_glfw.cpp + imgui_impl_vulkan.cpp

Compiler, OS:

windows 11

Full config/build information:

No response

Details:

Question is more about find a proper way to evaluate app GUI layout in a same-frame.

App has main window defined as MainDockSpace where I also define “Process”, “Info”, “Props” and “Image” windows dock layout for default look.
All windows except Image window has fixed width size.

When app run only Process window docked on the left.
When app open Image app also make visible windows with Info (mouse cords, image size, UI debug information etc.) and Props window for image (shader) manipulations or zoom, scroll, grid etc.

I have use Demo for Vulkan/GLFW as a reference and
Docking space, Menus, AppWindows run inside ImGUI::NewFrame / Render().

In code I try to utilize public ImGUI API but for image scale (zoom or fit to window) still need have window size from ImGUI.

Issues I had found at this moment:

• Even if Info and Props windows defined and initializing before Image Window and Process window already in place. Image windows after Begin get size equal of empty space in DockingSpace without Info/Props.
  Both are docked by default and have fixed size, so ImGui in theory can correctly evaluate available area wrt Process, Info and Props windows.
  So in first frame I don’t have correct sizes from ImGui.
• second NewFrame pass, ImageWindow still don’t get correct sizes from imgui and Info and Props still did not rendering, as well as ImageWindow
• only on third frame, I get all sizes app need to evaluate correct image size to fit it into a window and on Render() finally visible all windows.

At this moment I have a counter for image open that re-evaluate image size untill third frame. And I have feels that this is suboptimal. Because also have some issues with zooming and scroll positions.

I have an idea to use “dummy frames” and run ImGui::NewFrame() several times without call Render()
Maybe with some suppression for time/frame count. Only to force system re-evaluate gui in same frame for interactive events.

Or maybe there are more straight forward way to finish gui layout in same frame?

[ocornut]

Your words are a little difficult to understand, to make connecting elements could you provide a shot/video capture for context and a minimum code repro that exhibit the problem, so we can look at what you are doing code wise.

[ssh4net]

Same logic as in imgui demo:

...
        // Start the Dear ImGui frame
        ImGui_ImplVulkan_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        ImGuiStyle& style               = ImGui::GetStyle();
        style.DockingNodeHasCloseButton = false;

        Application();

        // Rendering
        ImGui::Render();
...

where Application();

void
Application()
{
    RemoveClosed();
    MainDockSpace();

    KeyboardIO();
    MouseWheel();

    Pipelines();
    Settings();

    int count = static_cast<int>(m_windows.size());

    if (count > 0 && m_pmg_state.LastFocusedWindow_idx >= 0 && m_pmg_state.LastFocusedWindow_idx < count) {
        PropsWindow(m_pmg_state.LastFocusedWindow_idx);
        InfoWindow(m_pmg_state.LastFocusedWindow_idx);
        RenderOrbWidgetControl(m_pmg_state.LastFocusedWindow_idx);
    }

    for (int i = 0; i < count; ++i) {
        ImageWindow(i);
    }
}

MainDockSpace()

...
    ImGui::Begin("MainDockSpace", nullptr, window_flags);

    AppMenuBar();

   if (node && node->IsEmpty()) {
       ImGui::DockBuilderRemoveNode(m_pmg_state.images_docks_id);
       ImGuiID dock_main_id = ImGui::DockBuilderAddNode(m_pmg_state.images_docks_id, ImGuiDockNodeFlags_None);
       ImGui::DockBuilderSetNodeSize(dock_main_id, viewport->Size);

       ImGuiID split_area_id;
       ImGuiID dock_pipeline_id, dock_image_id, dock_info_id, dock_props_id;

       ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, 0.5f, &dock_pipeline_id, &split_area_id);
       ImGui::DockBuilderSplitNode(split_area_id, ImGuiDir_Right, 0.5f, &dock_props_id, &split_area_id);
       ImGui::DockBuilderSplitNode(split_area_id, ImGuiDir_Right, 0.5f, &dock_info_id, &dock_image_id);

       // Mark the ImageWindowProps node as central node
       ImGuiDockNode* image_node = ImGui::DockBuilderGetNode(dock_image_id);
       if (image_node) {
           image_node->SetLocalFlags(image_node->LocalFlags | ImGuiDockNodeFlags_CentralNode);
       }

       ImGui::DockBuilderSetNodeSize(dock_pipeline_id, ImVec2(240.0f, viewport->Size.y));
       ImGui::DockBuilderSetNodeSize(dock_props_id, ImVec2(260.0f, viewport->Size.y));
       ImGui::DockBuilderSetNodeSize(dock_info_id, ImVec2(300.0f, viewport->Size.y));

       // Assign windows to dock nodes
       ImGui::DockBuilderDockWindow("Processing", dock_pipeline_id);
       ImGui::DockBuilderDockWindow("Image Info", dock_info_id);
       ImGui::DockBuilderDockWindow("Image Properties", dock_props_id);
       // ImageWindow(s) will dock to dock_image_id (center)

       ImGui::DockBuilderFinish(m_pmg_state.images_docks_id);
   }

   m_pmg_state.images_docks_node = ImGui::DockBuilderGetNode(m_pmg_state.images_docks_id);

   ImGui::End();
 
...

InfoWindow()

void
nfoWindow(const int idx)
{
    if (idx < 0 || idx >= static_cast<int>(m_windows.size()))
        return;

    if (!m_pmg_state.image_info_visible)
        return;

    ImageGuiProps& img_props   = *m_windows[idx].props;
    ImageWindowProps& m_window = *m_windows[idx].window;
    Image& image               = *m_windows[idx].image;

    ImVec2 fixedSizeMin = { 300.0f, -1.0f };
    ImVec2 fixedSizeMax = { 300.0f, FLT_MAX };

    ImGui::PushFont(m_font.f, 14.0f);

    ImGui::SetNextWindowSizeConstraints(fixedSizeMin, fixedSizeMax);
    ImGui::SetNextWindowSize(fixedSizeMin, ImGuiCond_Always);

    ImGuiWindowClass wc;
    wc.DockNodeFlagsOverrideSet |= ImGuiDockNodeFlags_NoResize;  // disable splitter move on this node
    ImGui::SetNextWindowClass(&wc);

    ImGui::Begin("Image Info", &m_pmg_state.image_info_visible);
...

    ImGui::End();
}

ImageWindow()

void
ImageWindow(const int idx)
{
    if (idx < 0 || idx >= static_cast<int>(m_windows.size()))
        return;

    Image& image               = *m_windows[idx].image;
    ImageGuiProps& img_props   = *m_windows[idx].props;
    ImageWindowProps& m_window = *m_windows[idx].window;

    if (!m_window.visible)
        return;

    if (!image.ready)
        return;

    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));

    ImageWindowLayout(idx); // Here i estimate image size using properties i have got from a previous frame

    ImGui::SetNextWindowDockID(m_pmg_state.images_docks_id, ImGuiCond_FirstUseEver);

    std::string window_title = m_window.title;

    ImGui::Begin(window_title.c_str(), &m_window.visible,
                 ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_NoSavedSettings);

...

    RenderImage(m_window.avail_size, img_props, m_window, idx, image);

// Here i store some window properties like content size, available size, scroll position etc.
// ...
// ...

    ImGui::End();
    ImGui::PopStyleVar();

}

In RenderImage() i use ImGui::BeginGroup();
and AddCallback() for custom shader with image processing or other shaders.

[ssh4net]

Last frame before Image Open.
No Image window and no props and info windows.

1st frame. Info and Props were already docked in code, but the window size and available size after Begin() ImageWindow return size that ignores Info and Props windows.
As a result, the image size is passed to a group and rendered incorrectly, and the image is cropped and does not fit the ImageWindow.

2nd frame. Here I finally have the correct Image window size wrt Info and Props windows.
Image size is correctly set to fit the window.

3rd frame. Scrolls disaperaing (as expected)

There are a lot more minor issues on how the available size is calculated with respect to the abbar and scrolls, so I need to manually estimate the available area without scrolls or track if the tabbar is hidden. That's critical to "Fit to window" when the window has scrolls. But maybe I just haven't found the right properties for that.

[ocornut]

I Thanks for the clarification!

code, but the window size and available size after Begin() ImageWindow return size that ignores Info and Props windows.

That should not happen. Your code calls this ImageWindowLayout() before Begin() , I don’t know what you are doing here. You would normally only call GetAvailContentSize() after Begin() to know how much you can fit.

If you can keep reducing your problem into its simplest form using hardcoded ImGui calls I’ll be able to run it. I’ll try to create that repro at some point (I’ve been ill recently).

[ssh4net]

Ignore this function; it was used in the original code where I needed to control almost all window properties, from image size, content size, scroll positions, etc. It only used to set image size atm.

I have added
ImGui::GetWindowPos();
ImGui::GetWindowSize();
before End() on all windows and in 0-th frame have this values.

Props Window

pos 1970 x 233
size 260 x 1007

Info WIndow

pos 1930 x 233
size 300 x 1007

ImageWindow

pos 571 x 233
size 1659 x 1007

Props and Info have the correct size, but the position looks suspicious, as the Info Window position depends on the Props size.
And the Info window gets a Full area size (App window - Process window size).
App window size is 1900x1040px, Display size is 2560x1440px. App window in the center of the screen.

[ocornut]

I'll investigate when I have time to turn your code into a repro.

[ssh4net]

@ocornut
Use this as a replacement for main.cpp in vulkan glfw demo.

main.zip

App starts with one window visible. To enable three other use Menu / View / Repro Windows.

And you can set a breakpoint inside a Props window to see the pos and size variables.
I have checked, and the windows' position in the 0th frame has the same issue as I mentioned above.

[ocornut]

Thanks!

And you can set a breakpoint inside a Props window to see the pos and size variables.

The size is only incorrect while the window is appearing and hidden.

Cleaned up repro below.

• I removed setting WindowPadding to 0.0f and added colored frame filling the window (minus padding) so we can actually see what's displayed and it if appears to overflow.
• Added a sleep(200) so we can see it happening.
• Added logging:

[00015] ImageProps  pos (1145.0,187.0) size (260.0, 772.0) hidden=1
[00015] InfoWindow  pos (1105.0,187.0) size (300.0, 772.0) hidden=1
[00015] ImageWindow pos (366.0,187.0) size (1039.0, 772.0) hidden=1

[00016] ImageProps  pos (1145.0,187.0) size (260.0, 772.0) hidden=0
[00016] InfoWindow  pos (844.0,187.0) size (300.0, 772.0) hidden=0
[00016] ImageWindow pos (366.0,187.0) size (477.0, 772.0) hidden=0

[00017] ImageProps  pos (1145.0,187.0) size (260.0, 772.0) hidden=0
[00017] InfoWindow  pos (844.0,187.0) size (300.0, 772.0) hidden=0
[00017] ImageWindow pos (366.0,187.0) size (477.0, 772.0) hidden=0

[...]

During the hidden frame none of the window are visible. Running with sleep(200) we don't see any visible glitch.

I'm pretty sure the problem is related to your actual code calling ImageWindowLayout() before Begin().
If you test Begin() return value and don't attempt to display you won't have a problem.
But supposedly you were recording and using "size of previous frame hidden window" which is an ordering issue?
(I agree it could be misleading that it reports a size there, we might want to report 0 during that time but it is the "previous" size)

// Includes
#include "imgui_internal.h"  // for ImGuiDockNode

// Global variables
bool g_ShouldClose = false;

struct ProgramState
{
    ImGuiID images_docks_id          = 0;
    ImGuiDockNode* images_docks_node = nullptr;
    bool show_pipelines_window       = true;
    bool other_visible               = false;
} m_pmg_state;


void AppMenuBar()
{
    // Menu
    if (ImGui::BeginMenuBar())
    {
        // square side = current row height
        const float sz = ImGui::GetFrameHeight();
        ImGui::SetCursorPosX(0.0f);  // kill the default left padding

        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.0f, 4.0f));

        if (ImGui::BeginMenu("File"))
        {
            if (ImGui::MenuItem("Exit", "Alt+F4"))
                g_ShouldClose = true;
            ImGui::EndMenu();
        }

        if (ImGui::BeginMenu("View"))
        {
            // Render properties window
            ImGui::MenuItem("Repro Windows", "", &m_pmg_state.other_visible);
            ImGui::EndMenu();
        }

        // add [x] close button to menu bar to right
        // Calculate close button position in screen coordinates
        ImVec2 window_pos       = ImGui::GetWindowPos();
        ImVec2 window_size      = ImGui::GetWindowSize();
        ImVec2 close_button_pos = ImVec2(window_pos.x + window_size.x - sz + 4.0f, window_pos.y + 8.0f);
        ImGuiID close_button_id = ImGui::GetID("##close_button");

        if (ImGui::CloseButton(close_button_id, close_button_pos))
            g_ShouldClose = true;

        ImGui::EndMenuBar();
        ImGui::PopStyleVar();
    }
}

void MainDockSpace()
{
    static bool s_ini_loaded = false;
    if (!s_ini_loaded)
    {
        ImGuiIO& io = ImGui::GetIO();
        if (io.IniFilename && *io.IniFilename)
            ImGui::LoadIniSettingsFromDisk(io.IniFilename);  // ensures docking tree is restored immediately FIXME: ??????
        s_ini_loaded = true;
    }

    ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
    const ImGuiViewport* viewport = ImGui::GetMainViewport();
    ImGui::SetNextWindowPos(viewport->Pos);
    ImGui::SetNextWindowSize(viewport->Size);
    ImGui::SetNextWindowViewport(viewport->ID);
    window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
    window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;

    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));

    ImGuiStyle& style = ImGui::GetStyle();
    const ImVec2 original_frame_padding = style.FramePadding;
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(original_frame_padding.x, original_frame_padding.y * 2.5f));

    ImGui::Begin("MainDockSpace", nullptr, window_flags);

    AppMenuBar();

    ImGui::PopStyleVar();

    // DockSpace
    m_pmg_state.images_docks_id   = ImGui::GetID("ImagesDockSpace");
    ImGuiDockNodeFlags dock_flags = ImGuiDockNodeFlags_PassthruCentralNode | ImGuiDockNodeFlags_None;
    ImGui::DockSpace(m_pmg_state.images_docks_id, ImVec2(0, 0), dock_flags);

    // Set up default layout on first use (only if not loaded from ini)
    ImGuiDockNode* node = ImGui::DockBuilderGetNode(m_pmg_state.images_docks_id);
    if (node && node->IsEmpty())
    {
        ImGui::DockBuilderRemoveNode(m_pmg_state.images_docks_id);
        ImGuiID dock_main_id = ImGui::DockBuilderAddNode(m_pmg_state.images_docks_id, ImGuiDockNodeFlags_None);
        ImGui::DockBuilderSetNodeSize(dock_main_id, viewport->Size);

        ImGuiID split_area_id;
        ImGuiID dock_pipeline_id, dock_image_id, dock_info_id, dock_props_id;

        ImGui::DockBuilderSplitNode(dock_main_id, ImGuiDir_Left, 0.5f, &dock_pipeline_id, &split_area_id);
        ImGui::DockBuilderSplitNode(split_area_id, ImGuiDir_Right, 0.5f, &dock_props_id, &split_area_id);
        ImGui::DockBuilderSplitNode(split_area_id, ImGuiDir_Right, 0.5f, &dock_info_id, &dock_image_id);

        // Mark the ImageWindowProps node as central node
        ImGuiDockNode* image_node = ImGui::DockBuilderGetNode(dock_image_id);
        if (image_node)
            image_node->SetLocalFlags(image_node->LocalFlags | ImGuiDockNodeFlags_CentralNode);

        ImGui::DockBuilderSetNodeSize(dock_pipeline_id, ImVec2(240.0f, viewport->Size.y));
        ImGui::DockBuilderSetNodeSize(dock_props_id, ImVec2(260.0f, viewport->Size.y));
        ImGui::DockBuilderSetNodeSize(dock_info_id, ImVec2(300.0f, viewport->Size.y));

        // Assign windows to dock nodes
        ImGui::DockBuilderDockWindow("Processing", dock_pipeline_id);
        ImGui::DockBuilderDockWindow("Image Info", dock_info_id);
        ImGui::DockBuilderDockWindow("Image Properties", dock_props_id);
        // ImageWindow(s) will dock to dock_image_id (center)

        ImGui::DockBuilderFinish(m_pmg_state.images_docks_id);
    }

    m_pmg_state.images_docks_node = ImGui::DockBuilderGetNode(m_pmg_state.images_docks_id);

    ImGui::End();
    ImGui::PopStyleVar();  // End of window padding style
}

void Contents()
{
    // Pipelines()
    {
        ImVec2 fixedSize = { 240.0f, 450.0f };

        ImGui::SetNextWindowSizeConstraints(fixedSize, fixedSize);
        ImGui::SetNextWindowSize(fixedSize, ImGuiCond_Always);

        ImGuiWindowClass wc;
        wc.DockNodeFlagsOverrideSet |= ImGuiDockNodeFlags_NoResize;  // disable splitter move on this node
        ImGui::SetNextWindowClass(&wc);

        ImGui::SetNextWindowDockID(m_pmg_state.images_docks_id, ImGuiCond_FirstUseEver);

        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.2f, 0.1f, 0.1f, 1.0f));

        ImGui::Begin("Processing", &m_pmg_state.show_pipelines_window);

        ImGui::Text("Pipeline controls");

        ImVec2 pos = ImGui::GetWindowPos();
        ImVec2 size = ImGui::GetWindowSize();

        ImVec2 cursor_pos = ImGui::GetCursorPos();
        ImVec2 mouse_pos = ImGui::GetMousePos();

        ImGui::End();

        ImGui::PopStyleColor();
    }

    // PropsWindow
    if (m_pmg_state.other_visible)
    {
        ImVec2 fixedSizeMin = { 260.0f, -1.0f };
        ImVec2 fixedSizeMax = { 260.0f, FLT_MAX };

        ImGui::SetNextWindowSizeConstraints(fixedSizeMin, fixedSizeMax);
        ImGui::SetNextWindowSize(fixedSizeMin, ImGuiCond_Always);

        ImGuiWindowClass wc;
        wc.DockNodeFlagsOverrideSet |= ImGuiDockNodeFlags_NoResize;  // disable splitter move on this node
        ImGui::SetNextWindowClass(&wc);

        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.2f, 0.1f, 1.0f));

        ImGui::Begin("Image Properties", &m_pmg_state.other_visible);

        ImGui::Text("Image properties");

        ImVec2 pos = ImGui::GetWindowPos();
        ImVec2 size = ImGui::GetWindowSize();
        IMGUI_DEBUG_LOG("%s pos (%5.1f,%5.1f) size (%5.1f, %5.1f) hidden=%d\n",
            "ImageProps ",
            pos.x, pos.y, size.x, size.y, ImGui::GetCurrentWindow()->Hidden);

        ImGui::End();

        ImGui::PopStyleColor();
    }

    // InfoWindow
    if (m_pmg_state.other_visible)
    {
        ImVec2 fixedSizeMin = { 300.0f, -1.0f };
        ImVec2 fixedSizeMax = { 300.0f, FLT_MAX };

        ImGui::SetNextWindowSizeConstraints(fixedSizeMin, fixedSizeMax);
        ImGui::SetNextWindowSize(fixedSizeMin, ImGuiCond_Always);

        ImGuiWindowClass wc;
        wc.DockNodeFlagsOverrideSet |= ImGuiDockNodeFlags_NoResize;  // disable splitter move on this node
        ImGui::SetNextWindowClass(&wc);

        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.1f, 0.1f, 0.2f, 1.0f));

        ImGui::Begin("Image Info", &m_pmg_state.other_visible);
        ImGui::Text("Image info");

        ImVec2 pos = ImGui::GetWindowPos();
        ImVec2 size = ImGui::GetWindowSize();
        IMGUI_DEBUG_LOG("%s pos (%5.1f,%5.1f) size (%5.1f, %5.1f) hidden=%d\n",
            "InfoWindow ",
            pos.x, pos.y, size.x, size.y, ImGui::GetCurrentWindow()->Hidden);

        ImGui::End();

        ImGui::PopStyleColor();
    }

    // ImageWindow
    if (m_pmg_state.other_visible)
    {
        //ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));

        ImGui::SetNextWindowDockID(m_pmg_state.images_docks_id, ImGuiCond_FirstUseEver);

        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.2f, 0.2f, 0.2f, 1.0f));

        ImGui::Begin("Image Window", &m_pmg_state.other_visible);
        ImGui::Text("Image would be shown here");

        ImVec2 pos = ImGui::GetWindowPos();
        ImVec2 size = ImGui::GetWindowSize();
        IMGUI_DEBUG_LOG("%s pos (%5.1f,%5.1f) size (%5.1f, %5.1f) hidden=%d\n",
            "ImageWindow",
            pos.x, pos.y, size.x, size.y, ImGui::GetCurrentWindow()->Hidden);
        ImGui::ColorButton("##foo", ImVec4(0.3f, 0.3f, 0.3f, 1.0f), 0, ImGui::GetContentRegionAvail());

        ImGui::End();
        ImGui::PopStyleColor();
        //ImGui::PopStyleVar();
    }
}

    // My style
    style.WindowRounding       = 0.0f;
    style.FrameRounding        = 0.0f;
    style.WindowBorderSize     = 0.0f;
    style.PopupBorderSize      = 0.0f;
    style.FrameBorderSize      = 0.0f;
    style.TabRounding          = 1.0f;
    style.DockingSeparatorSize = 1.0f;
    style.DockingNodeHasCloseButton = false;
    io.ConfigWindowsMoveFromTitleBarOnly = true;

        // MainDockSpace
        MainDockSpace();
        Contents();
        if (g_ShouldClose)
            glfwSetWindowShouldClose(window, GLFW_TRUE);

        ImGui_ImplGlfw_Sleep(200);

[ocornut]

Misc feedback unrelated to code issue:

(1) the call to LoadIniSettingsFromDisk() in your code seems unnecessary and misleading.
(2) you might know that it is possible to change:

    const ImVec2 original_frame_padding = style.FramePadding;
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(original_frame_padding.x, original_frame_padding.y * 2.5f));

into:

    ImGui::PushStyleVar(ImGuiStyleVar_FramePaddingY, style.FramePadding * 2.5f);

(3)
I believe the bulk of your MainDockSpace() function could be turned into a DockspaceOverViewport() call and you replace BeginMenuBar() with BeginMainMenuBar().

(4)
For default settings: I guess if (node && node->IsEmpty()) kinda works but it would be more correct to test for if (DockBuilderGetNode(...) == NULL) before the first call to DockSpace(). This way the user can decide to save a state where nothing is docked into the main viewport.

(5)
I also noticed you are storing images_docks_node which is not used in the repro, and may be related to your actual issue.

(6)
Neither SetNextWindowSizeConstraints() nor SetNextWindowSize() are currently unsupported for docked window (#2849)

Not related to your main problem, but if I may provide an advice: you seem to be pushing against some of the limitation of docking systems. You would make your life easier by not adding too many constraint or the ImGuiDockNodeFlags_NoResize.

[ssh4net]

into:

    ImGui::PushStyleVar(ImGuiStyleVar_FramePaddingY, style.FramePadding * 2.5f);

There is no ImGuiStyleVar_FramePaddingY in ImGuiStyleVar_ enum

Thanx regarding BeginMainMenuBar() i thought i have changed it already :)

[ocornut]

Sorry it is PushStyleVarY() function:

[ssh4net]

@ocornut I think I can't use DockspaceOverViewport() as it's good for full-screen apps. When i need windowed one.

And still not solving my problem. Even if the app already knows the size and position of the Process, Info, and Props windows. I can't get the available size, and can only get it on the 1st frame.

What do you think about "dummy" frame as a workaround? Looks like in theory I can skip a render and pass ImGUI corrected times/frames to have one skipped frame.

Or is this only a dream for immediate mode UI?

[ocornut]

I took your repro and showed you how the available content value was correct for every visible frame. Please clarify how/why that does not solve your problem.

You seem to be overthinking or cargo culting or working around a problem which either should not happen either that you haven’t clarified yet.

Please prefer sharing code and raw data log rather than statements which may be ambiguous or misleading, so we can get faster to a solution.

And still not solving my problem. Even if the app already knows the size and position of the Process, Info, and Props windows.

You should not need to care or know about the size or position of anything.

I can't get the available size, and can only get it on the 1st frame.

My log above which is based on your code shows that the available size is correct and provided for all visible frames. Please show me otherwise with hard data. Otherwise it is a mistake in code that you omitted.