imgui: Infinite loop in TabBar resizing

Can you try this version.? Only replacing the final loop from the current commit:

    while (width_excess > 0.0f)
        for (int n = 0; n < count && width_excess > 0.0f; n++)
        {
            float width_to_add = ImMin(items[n].InitialWidth - items[n].Width, 1.0f);
            items[n].Width += width_to_add;
            width_excess -= width_to_add;
        }

The thing I checked are:

• Using rounded widths, the right most tabs is always at the same pixel distance to the right of the tab bar.
• Using rounded widths, the relative spacing between each tabs never changes.
• Can’t get it to infinite loop with non-rounded widths.

Issues (that are not new)

• Using non-rounded widths result in subtle offset when starting to resize, because we round output at this point (not new), technically easier to fix, could do.
• Using non-rounded widths still result in subtle wobbling but that’s due to layout system (not new)

It’s not perfect for non-rounded width but nothing in Dear ImGui currently is (*)

* Amusingly, at the time I am typing this into Firefox, the textbox height keeps resizing back-and-worth between +0 and +1 pixels whenever I type… Guess some other code has tricky rounding issue…

so probably what happens is that there is more than one pixel width_excess but all the individual tabs still only receive less than one pixel offset? how about a single-pass floyd-steinberg diffusion instead?

    // Round width and redistribute remainder
    // floyd steinberg diffusion:
    width_excess = 0.0f;
    for(int n = 0; n < count; n++)
    {
        items[n].Width += width_excess;
        float width_rounded = ImFloor(items[n].Width);
        width_excess += items[n].Width - width_rounded;
        items[n].Width = width_rounded;
    }

(patch attached, had to gzip it so github would accept it) 0001-tabbar-propose-to-distribute-widths-via-floyd-steinb.patch.gz

These are two example inputs that lead to inifinite loops for me with the code in its current state:

// GImGui->CurrentWindow->Size = { 1269, 956 }
ImGuiShrinkWidthItem testItemsA[] =
{
	{ 0, 99.0000000f, 99.0000000f },
	{ 1, 110.952225f, 110.952225f },
	{ 2, 84.9522247f, 84.9522247f },
	{ 3, 144.952225f, 144.952225f },
};
ImGui::ShrinkWidths(testItemsA, 4, 1.80895996f);

// GImGui->CurrentWindow->Size = { 1269, 956 }
ImGuiShrinkWidthItem testItemsB[] =
{
	{ 0, 99.0000000f, 99.0000000f },
	{ 1, 110.953949f, 110.953949f },
	{ 2, 84.9539490f, 84.9539490f },
	{ 3, 144.953949f, 144.953949f },
};
ImGui::ShrinkWidths(testItemsB, 4, 1.81582642f);

From my limited testing the single pass floyd steinberg diffusion approach appears to be working quite well here without any obvious issues 👍🏿