blame: source/code/Libs/imgui/imgui_widgets.cpp

// dear imgui, v1.92.3

// (widgets code)

/*

Index of this file:

// [SECTION] Forward Declarations

// [SECTION] Widgets: Text, etc.

// [SECTION] Widgets: Main (Button, Image, Checkbox, RadioButton, ProgressBar, Bullet, etc.)

// [SECTION] Widgets: Low-level Layout helpers (Spacing, Dummy, NewLine, Separator, etc.)

// [SECTION] Widgets: ComboBox

// [SECTION] Data Type and Data Formatting Helpers

// [SECTION] Widgets: DragScalar, DragFloat, DragInt, etc.

// [SECTION] Widgets: SliderScalar, SliderFloat, SliderInt, etc.

// [SECTION] Widgets: InputScalar, InputFloat, InputInt, etc.

// [SECTION] Widgets: InputText, InputTextMultiline

// [SECTION] Widgets: ColorEdit, ColorPicker, ColorButton, etc.

// [SECTION] Widgets: TreeNode, CollapsingHeader, etc.

// [SECTION] Widgets: Selectable

// [SECTION] Widgets: Typing-Select support

// [SECTION] Widgets: Box-Select support

// [SECTION] Widgets: Multi-Select support

// [SECTION] Widgets: Multi-Select helpers

// [SECTION] Widgets: ListBox

// [SECTION] Widgets: PlotLines, PlotHistogram

// [SECTION] Widgets: Value helpers

// [SECTION] Widgets: MenuItem, BeginMenu, EndMenu, etc.

// [SECTION] Widgets: BeginTabBar, EndTabBar, etc.

// [SECTION] Widgets: BeginTabItem, EndTabItem, etc.

// [SECTION] Widgets: Columns, BeginColumns, EndColumns, etc.

*/

#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)

#define _CRT_SECURE_NO_WARNINGS

#endif

#ifndef IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

#endif

#include "imgui.h"

#ifndef IMGUI_DISABLE

#include "imgui_internal.h"

// System includes

#include <stdint.h>     // intptr_t

//-------------------------------------------------------------------------

// Warnings

//-------------------------------------------------------------------------

// Visual Studio warnings

#ifdef _MSC_VER

#pragma warning (disable: 4127)     // condition expression is constant

#pragma warning (disable: 4996)     // 'This function or variable may be unsafe': strcpy, strdup, sprintf, vsnprintf, sscanf, fopen

#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later

#pragma warning (disable: 5054)     // operator '|': deprecated between enumerations of different types

#endif

#pragma warning (disable: 26451)    // [Static Analyzer] Arithmetic overflow : Using operator 'xxx' on a 4 byte value and then casting the result to a 8 byte value. Cast the value to the wider type before calling operator 'xxx' to avoid overflow(io.2).

#pragma warning (disable: 26812)    // [Static Analyzer] The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).

#endif

// Clang/GCC warnings with -Weverything

#if defined(__clang__)

#if __has_warning("-Wunknown-warning-option")

#pragma clang diagnostic ignored "-Wunknown-warning-option"         // warning: unknown warning group 'xxx'                      // not all warnings are known by all Clang versions and they tend to be rename-happy.. so ignoring warnings triggers new warnings on some configuration. Great!

#endif

#pragma clang diagnostic ignored "-Wunknown-pragmas"                // warning: unknown warning group 'xxx'

#pragma clang diagnostic ignored "-Wold-style-cast"                 // warning: use of old-style cast                            // yes, they are more terse.

#pragma clang diagnostic ignored "-Wfloat-equal"                    // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants (typically 0.0f) is ok.

#pragma clang diagnostic ignored "-Wformat"                         // warning: format specifies type 'int' but the argument has type 'unsigned int'

#pragma clang diagnostic ignored "-Wformat-nonliteral"              // warning: format string is not a string literal            // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.

#pragma clang diagnostic ignored "-Wsign-conversion"                // warning: implicit conversion changes signedness

#pragma clang diagnostic ignored "-Wunused-macros"                  // warning: macro is not used                                // we define snprintf/vsnprintf on Windows so they are available, but not always used.

#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"  // warning: zero as null pointer constant                    // some standard header variations use #define NULL 0

#pragma clang diagnostic ignored "-Wdouble-promotion"               // warning: implicit conversion from 'float' to 'double' when passing argument to function  // using printf() is a misery with this as C++ va_arg ellipsis changes float to double.

#pragma clang diagnostic ignored "-Wenum-enum-conversion"           // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_')

#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"// warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"  // warning: implicit conversion from 'xxx' to 'float' may lose precision

#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"            // warning: 'xxx' is an unsafe pointer used for buffer access

#pragma clang diagnostic ignored "-Wnontrivial-memaccess"           // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type

#pragma clang diagnostic ignored "-Wswitch-default"                 // warning: 'switch' missing 'default' label

#elif defined(__GNUC__)

#pragma GCC diagnostic ignored "-Wpragmas"                          // warning: unknown option after '#pragma GCC diagnostic' kind

#pragma GCC diagnostic ignored "-Wfloat-equal"                      // warning: comparing floating-point with '==' or '!=' is unsafe

#pragma GCC diagnostic ignored "-Wformat"                           // warning: format '%p' expects argument of type 'int'/'void*', but argument X has type 'unsigned int'/'ImGuiWindow*'

#pragma GCC diagnostic ignored "-Wformat-nonliteral"                // warning: format not a string literal, format string not checked

#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"  // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

#pragma GCC diagnostic ignored "-Wdouble-promotion"                 // warning: implicit conversion from 'float' to 'double' when passing argument to function

#pragma GCC diagnostic ignored "-Wstrict-overflow"                  // warning: assuming signed overflow does not occur when simplifying division / ..when changing X +- C1 cmp C2 to X cmp C2 -+ C1

#pragma GCC diagnostic ignored "-Wclass-memaccess"                  // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead

#pragma GCC diagnostic ignored "-Wcast-qual"                        // warning: cast from type 'const xxxx *' to type 'xxxx *' casts away qualifiers

#endif

//-------------------------------------------------------------------------

// Data

//-------------------------------------------------------------------------

// Widgets

static const float          DRAGDROP_HOLD_TO_OPEN_TIMER = 0.70f;    // Time for drag-hold to activate items accepting the ImGuiButtonFlags_PressedOnDragDropHold button behavior.

static const float          DRAG_MOUSE_THRESHOLD_FACTOR = 0.50f;    // Multiplier for the default value of io.MouseDragThreshold to make DragFloat/DragInt react faster to mouse drags.

// Those MIN/MAX values are not define because we need to point to them

static const signed char    IM_S8_MIN  = -128;

static const signed char    IM_S8_MAX  = 127;

static const unsigned char  IM_U8_MIN  = 0;

static const unsigned char  IM_U8_MAX  = 0xFF;

static const signed short   IM_S16_MIN = -32768;

static const signed short   IM_S16_MAX = 32767;

static const unsigned short IM_U16_MIN = 0;

static const unsigned short IM_U16_MAX = 0xFFFF;

static const ImS32          IM_S32_MIN = INT_MIN;    // (-2147483647 - 1), (0x80000000);

static const ImS32          IM_S32_MAX = INT_MAX;    // (2147483647), (0x7FFFFFFF)

static const ImU32          IM_U32_MIN = 0;

static const ImU32          IM_U32_MAX = UINT_MAX;   // (0xFFFFFFFF)

#ifdef LLONG_MIN

static const ImS64          IM_S64_MIN = LLONG_MIN;  // (-9223372036854775807ll - 1ll);

static const ImS64          IM_S64_MAX = LLONG_MAX;  // (9223372036854775807ll);

#else

static const ImS64          IM_S64_MIN = -9223372036854775807LL - 1;

static const ImS64          IM_S64_MAX = 9223372036854775807LL;

#endif

static const ImU64          IM_U64_MIN = 0;

#ifdef ULLONG_MAX

static const ImU64          IM_U64_MAX = ULLONG_MAX; // (0xFFFFFFFFFFFFFFFFull);

#else

static const ImU64          IM_U64_MAX = (2ULL * 9223372036854775807LL + 1);

#endif

//-------------------------------------------------------------------------

// [SECTION] Forward Declarations

//-------------------------------------------------------------------------

// For InputTextEx()

static bool     InputTextFilterCharacter(ImGuiContext* ctx, unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data, bool input_source_is_clipboard = false);

static ImVec2   InputTextCalcTextSize(ImGuiContext* ctx, const char* text_begin, const char* text_end_display, const char* text_end, const char** out_remaining = NULL, ImVec2* out_offset = NULL, ImDrawTextFlags flags = 0);

//-------------------------------------------------------------------------

// [SECTION] Widgets: Text, etc.

//-------------------------------------------------------------------------

// - TextEx() [Internal]

// - TextUnformatted()

// - Text()

// - TextV()

// - TextColored()

// - TextColoredV()

// - TextDisabled()

// - TextDisabledV()

// - TextWrapped()

// - TextWrappedV()

// - LabelText()

// - LabelTextV()

// - BulletText()

// - BulletTextV()

//-------------------------------------------------------------------------

void ImGui::TextEx(const char* text, const char* text_end, ImGuiTextFlags flags)

{

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return;

    ImGuiContext& g = *GImGui;

    // Accept null ranges

    if (text == text_end)

        text = text_end = "";

    // Calculate length

    const char* text_begin = text;

    if (text_end == NULL)

        text_end = text + ImStrlen(text); // FIXME-OPT

    const ImVec2 text_pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);

    const float wrap_pos_x = window->DC.TextWrapPos;

    const bool wrap_enabled = (wrap_pos_x >= 0.0f);

    if (text_end - text <= 2000 || wrap_enabled)

    {

        // Common case

        const float wrap_width = wrap_enabled ? CalcWrapWidthForPos(window->DC.CursorPos, wrap_pos_x) : 0.0f;

        const ImVec2 text_size = CalcTextSize(text_begin, text_end, false, wrap_width);

        ImRect bb(text_pos, text_pos + text_size);

        ItemSize(text_size, 0.0f);

        if (!ItemAdd(bb, 0))

            return;

        // Render (we don't hide text after ## in this end-user function)

        RenderTextWrapped(bb.Min, text_begin, text_end, wrap_width);

    }

    else

    {

        // Long text!

        // Perform manual coarse clipping to optimize for long multi-line text

        // - From this point we will only compute the width of lines that are visible. Optimization only available when word-wrapping is disabled.

        // - We also don't vertically center the text within the line full height, which is unlikely to matter because we are likely the biggest and only item on the line.

        // - We use memchr(), pay attention that well optimized versions of those str/mem functions are much faster than a casually written loop.

        const char* line = text;

        const float line_height = GetTextLineHeight();

        ImVec2 text_size(0, 0);

        // Lines to skip (can't skip when logging text)

        ImVec2 pos = text_pos;

        if (!g.LogEnabled)

        {

            int lines_skippable = (int)((window->ClipRect.Min.y - text_pos.y) / line_height);

            if (lines_skippable > 0)

            {

                int lines_skipped = 0;

                while (line < text_end && lines_skipped < lines_skippable)

                {

                    const char* line_end = (const char*)ImMemchr(line, '\n', text_end - line);

                    if (!line_end)

                        line_end = text_end;

                    if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)

                        text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);

                    line = line_end + 1;

                    lines_skipped++;

                }

                pos.y += lines_skipped * line_height;

            }

        }

        // Lines to render

        if (line < text_end)

        {

            ImRect line_rect(pos, pos + ImVec2(FLT_MAX, line_height));

            while (line < text_end)

            {

                if (IsClippedEx(line_rect, 0))

                    break;

                const char* line_end = (const char*)ImMemchr(line, '\n', text_end - line);

                if (!line_end)

                    line_end = text_end;

                text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);

                RenderText(pos, line, line_end, false);

                line = line_end + 1;

                line_rect.Min.y += line_height;

                line_rect.Max.y += line_height;

                pos.y += line_height;

            }

            // Count remaining lines

            int lines_skipped = 0;

            while (line < text_end)

            {

                const char* line_end = (const char*)ImMemchr(line, '\n', text_end - line);

                if (!line_end)

                    line_end = text_end;

                if ((flags & ImGuiTextFlags_NoWidthForLargeClippedText) == 0)

                    text_size.x = ImMax(text_size.x, CalcTextSize(line, line_end).x);

                line = line_end + 1;

                lines_skipped++;

            }

            pos.y += lines_skipped * line_height;

        }

        text_size.y = (pos - text_pos).y;

        ImRect bb(text_pos, text_pos + text_size);

        ItemSize(text_size, 0.0f);

        ItemAdd(bb, 0);

    }

}

void ImGui::TextUnformatted(const char* text, const char* text_end)

{

    TextEx(text, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);

}

void ImGui::Text(const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    TextV(fmt, args);

    va_end(args);

}

void ImGui::TextV(const char* fmt, va_list args)

{

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return;

    const char* text, *text_end;

    ImFormatStringToTempBufferV(&text, &text_end, fmt, args);

    TextEx(text, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);

}

void ImGui::TextColored(const ImVec4& col, const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    TextColoredV(col, fmt, args);

    va_end(args);

}

void ImGui::TextColoredV(const ImVec4& col, const char* fmt, va_list args)

{

    PushStyleColor(ImGuiCol_Text, col);

    TextV(fmt, args);

    PopStyleColor();

}

void ImGui::TextDisabled(const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    TextDisabledV(fmt, args);

    va_end(args);

}

void ImGui::TextDisabledV(const char* fmt, va_list args)

{

    ImGuiContext& g = *GImGui;

    PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);

    TextV(fmt, args);

    PopStyleColor();

}

void ImGui::TextWrapped(const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    TextWrappedV(fmt, args);

    va_end(args);

}

void ImGui::TextWrappedV(const char* fmt, va_list args)

{

    ImGuiContext& g = *GImGui;

    const bool need_backup = (g.CurrentWindow->DC.TextWrapPos < 0.0f);  // Keep existing wrap position if one is already set

    if (need_backup)

        PushTextWrapPos(0.0f);

    TextV(fmt, args);

    if (need_backup)

        PopTextWrapPos();

}

void ImGui::TextAligned(float align_x, float size_x, const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    TextAlignedV(align_x, size_x, fmt, args);

    va_end(args);

}

// align_x: 0.0f = left, 0.5f = center, 1.0f = right.

// size_x : 0.0f = shortcut for GetContentRegionAvail().x

// FIXME-WIP: Works but API is likely to be reworked. This is designed for 1 item on the line. (#7024)

void ImGui::TextAlignedV(float align_x, float size_x, const char* fmt, va_list args)

{

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return;

    const char* text, *text_end;

    ImFormatStringToTempBufferV(&text, &text_end, fmt, args);

    const ImVec2 text_size = CalcTextSize(text, text_end);

    size_x = CalcItemSize(ImVec2(size_x, 0.0f), 0.0f, text_size.y).x;

    ImVec2 pos(window->DC.CursorPos.x, window->DC.CursorPos.y + window->DC.CurrLineTextBaseOffset);

    ImVec2 pos_max(pos.x + size_x, window->ClipRect.Max.y);

    ImVec2 size(ImMin(size_x, text_size.x), text_size.y);

    window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, pos.x + text_size.x);

    window->DC.IdealMaxPos.x = ImMax(window->DC.IdealMaxPos.x, pos.x + text_size.x);

    if (align_x > 0.0f && text_size.x < size_x)

        pos.x += ImTrunc((size_x - text_size.x) * align_x);

    RenderTextEllipsis(window->DrawList, pos, pos_max, pos_max.x, text, text_end, &text_size);

    const ImVec2 backup_max_pos = window->DC.CursorMaxPos;

    ItemSize(size);

    ItemAdd(ImRect(pos, pos + size), 0);

    window->DC.CursorMaxPos.x = backup_max_pos.x; // Cancel out extending content size because right-aligned text would otherwise mess it up.

    if (size_x < text_size.x && IsItemHovered(ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_ForTooltip))

        SetTooltip("%.*s", (int)(text_end - text), text);

}

void ImGui::LabelText(const char* label, const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    LabelTextV(label, fmt, args);

    va_end(args);

}

// Add a label+text combo aligned to other label+value widgets

void ImGui::LabelTextV(const char* label, const char* fmt, va_list args)

{

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return;

    ImGuiContext& g = *GImGui;

    const ImGuiStyle& style = g.Style;

    const float w = CalcItemWidth();

    const char* value_text_begin, *value_text_end;

    ImFormatStringToTempBufferV(&value_text_begin, &value_text_end, fmt, args);

    const ImVec2 value_size = CalcTextSize(value_text_begin, value_text_end, false);

    const ImVec2 label_size = CalcTextSize(label, NULL, true);

    const ImVec2 pos = window->DC.CursorPos;

    const ImRect value_bb(pos, pos + ImVec2(w, value_size.y + style.FramePadding.y * 2));

    const ImRect total_bb(pos, pos + ImVec2(w + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), ImMax(value_size.y, label_size.y) + style.FramePadding.y * 2));

    ItemSize(total_bb, style.FramePadding.y);

    if (!ItemAdd(total_bb, 0))

        return;

    // Render

    RenderTextClipped(value_bb.Min + style.FramePadding, value_bb.Max, value_text_begin, value_text_end, &value_size, ImVec2(0.0f, 0.0f));

    if (label_size.x > 0.0f)

        RenderText(ImVec2(value_bb.Max.x + style.ItemInnerSpacing.x, value_bb.Min.y + style.FramePadding.y), label);

}

void ImGui::BulletText(const char* fmt, ...)

{

    va_list args;

    va_start(args, fmt);

    BulletTextV(fmt, args);

    va_end(args);

}

// Text with a little bullet aligned to the typical tree node.

void ImGui::BulletTextV(const char* fmt, va_list args)

{

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return;

    ImGuiContext& g = *GImGui;

    const ImGuiStyle& style = g.Style;

    const char* text_begin, *text_end;

    ImFormatStringToTempBufferV(&text_begin, &text_end, fmt, args);

    const ImVec2 label_size = CalcTextSize(text_begin, text_end, false);

    const ImVec2 total_size = ImVec2(g.FontSize + (label_size.x > 0.0f ? (label_size.x + style.FramePadding.x * 2) : 0.0f), label_size.y);  // Empty text doesn't add padding

    ImVec2 pos = window->DC.CursorPos;

    pos.y += window->DC.CurrLineTextBaseOffset;

    ItemSize(total_size, 0.0f);

    const ImRect bb(pos, pos + total_size);

    if (!ItemAdd(bb, 0))

        return;

    // Render

    ImU32 text_col = GetColorU32(ImGuiCol_Text);

    RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, g.FontSize * 0.5f), text_col);

    RenderText(bb.Min + ImVec2(g.FontSize + style.FramePadding.x * 2, 0.0f), text_begin, text_end, false);

}

//-------------------------------------------------------------------------

// [SECTION] Widgets: Main

//-------------------------------------------------------------------------

// - ButtonBehavior() [Internal]

// - Button()

// - SmallButton()

// - InvisibleButton()

// - ArrowButton()

// - CloseButton() [Internal]

// - CollapseButton() [Internal]

// - GetWindowScrollbarID() [Internal]

// - GetWindowScrollbarRect() [Internal]

// - Scrollbar() [Internal]

// - ScrollbarEx() [Internal]

// - Image()

// - ImageButton()

// - Checkbox()

// - CheckboxFlagsT() [Internal]

// - CheckboxFlags()

// - RadioButton()

// - ProgressBar()

// - Bullet()

// - Hyperlink()

//-------------------------------------------------------------------------

// The ButtonBehavior() function is key to many interactions and used by many/most widgets.

// Because we handle so many cases (keyboard/gamepad navigation, drag and drop) and many specific behavior (via ImGuiButtonFlags_),

// this code is a little complex.

// By far the most common path is interacting with the Mouse using the default ImGuiButtonFlags_PressedOnClickRelease button behavior.

// See the series of events below and the corresponding state reported by dear imgui:

//------------------------------------------------------------------------------------------------------------------------------------------------

// with PressedOnClickRelease:             return-value  IsItemHovered()  IsItemActive()  IsItemActivated()  IsItemDeactivated()  IsItemClicked()

//   Frame N+0 (mouse is outside bb)        -             -                -               -                  -                    -

//   Frame N+1 (mouse moves inside bb)      -             true             -               -                  -                    -

//   Frame N+2 (mouse button is down)       -             true             true            true               -                    true

//   Frame N+3 (mouse button is down)       -             true             true            -                  -                    -

//   Frame N+4 (mouse moves outside bb)     -             -                true            -                  -                    -

//   Frame N+5 (mouse moves inside bb)      -             true             true            -                  -                    -

//   Frame N+6 (mouse button is released)   true          true             -               -                  true                 -

//   Frame N+7 (mouse button is released)   -             true             -               -                  -                    -

//   Frame N+8 (mouse moves outside bb)     -             -                -               -                  -                    -

//------------------------------------------------------------------------------------------------------------------------------------------------

// with PressedOnClick:                    return-value  IsItemHovered()  IsItemActive()  IsItemActivated()  IsItemDeactivated()  IsItemClicked()

//   Frame N+2 (mouse button is down)       true          true             true            true               -                    true

//   Frame N+3 (mouse button is down)       -             true             true            -                  -                    -

//   Frame N+6 (mouse button is released)   -             true             -               -                  true                 -

//   Frame N+7 (mouse button is released)   -             true             -               -                  -                    -

//------------------------------------------------------------------------------------------------------------------------------------------------

// with PressedOnRelease:                  return-value  IsItemHovered()  IsItemActive()  IsItemActivated()  IsItemDeactivated()  IsItemClicked()

//   Frame N+2 (mouse button is down)       -             true             -               -                  -                    true

//   Frame N+3 (mouse button is down)       -             true             -               -                  -                    -

//   Frame N+6 (mouse button is released)   true          true             -               -                  -                    -

//   Frame N+7 (mouse button is released)   -             true             -               -                  -                    -

//------------------------------------------------------------------------------------------------------------------------------------------------

// with PressedOnDoubleClick:              return-value  IsItemHovered()  IsItemActive()  IsItemActivated()  IsItemDeactivated()  IsItemClicked()

//   Frame N+0 (mouse button is down)       -             true             -               -                  -                    true

//   Frame N+1 (mouse button is down)       -             true             -               -                  -                    -

//   Frame N+2 (mouse button is released)   -             true             -               -                  -                    -

//   Frame N+3 (mouse button is released)   -             true             -               -                  -                    -

//   Frame N+4 (mouse button is down)       true          true             true            true               -                    true

//   Frame N+5 (mouse button is down)       -             true             true            -                  -                    -

//   Frame N+6 (mouse button is released)   -             true             -               -                  true                 -

//   Frame N+7 (mouse button is released)   -             true             -               -                  -                    -

//------------------------------------------------------------------------------------------------------------------------------------------------

// Note that some combinations are supported,

// - PressedOnDragDropHold can generally be associated with any flag.

// - PressedOnDoubleClick can be associated by PressedOnClickRelease/PressedOnRelease, in which case the second release event won't be reported.

//------------------------------------------------------------------------------------------------------------------------------------------------

// The behavior of the return-value changes when ImGuiItemFlags_ButtonRepeat is set:

//                                         Repeat+                  Repeat+           Repeat+             Repeat+

//                                         PressedOnClickRelease    PressedOnClick    PressedOnRelease    PressedOnDoubleClick

//-------------------------------------------------------------------------------------------------------------------------------------------------

//   Frame N+0 (mouse button is down)       -                        true              -                   true

//   ...                                    -                        -                 -                   -

//   Frame N + RepeatDelay                  true                     true              -                   true

//   ...                                    -                        -                 -                   -

//   Frame N + RepeatDelay + RepeatRate*N   true                     true              -                   true

//-------------------------------------------------------------------------------------------------------------------------------------------------

// - FIXME: For refactor we could output flags, incl mouse hovered vs nav keyboard vs nav triggered etc.

//   And better standardize how widgets use 'GetColor32((held && hovered) ? ... : hovered ? ...)' vs 'GetColor32(held ? ... : hovered ? ...);'

//   For mouse feedback we typically prefer the 'held && hovered' test, but for nav feedback not always. Outputting hovered=true on Activation may be misleading.

// - Since v1.91.2 (Sept 2024) we included io.ConfigDebugHighlightIdConflicts feature.

//   One idiom which was previously valid which will now emit a warning is when using multiple overlaid ButtonBehavior()

//   with same ID and different MouseButton (see #8030). You can fix it by:

//       (1) switching to use a single ButtonBehavior() with multiple _MouseButton flags.

//    or (2) surrounding those calls with PushItemFlag(ImGuiItemFlags_AllowDuplicateId, true); ... PopItemFlag()

bool ImGui::ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags)

{

    ImGuiContext& g = *GImGui;

    ImGuiWindow* window = GetCurrentWindow();

    // Default behavior inherited from item flags

    // Note that _both_ ButtonFlags and ItemFlags are valid sources, so copy one into the item_flags and only check that.

    ImGuiItemFlags item_flags = (g.LastItemData.ID == id ? g.LastItemData.ItemFlags : g.CurrentItemFlags);

    if (flags & ImGuiButtonFlags_AllowOverlap)

        item_flags |= ImGuiItemFlags_AllowOverlap;

    if (item_flags & ImGuiItemFlags_NoFocus)

        flags |= ImGuiButtonFlags_NoFocus | ImGuiButtonFlags_NoNavFocus;

    // Default only reacts to left mouse button

    if ((flags & ImGuiButtonFlags_MouseButtonMask_) == 0)

        flags |= ImGuiButtonFlags_MouseButtonLeft;

    // Default behavior requires click + release inside bounding box

    if ((flags & ImGuiButtonFlags_PressedOnMask_) == 0)

        flags |= (item_flags & ImGuiItemFlags_ButtonRepeat) ? ImGuiButtonFlags_PressedOnClick : ImGuiButtonFlags_PressedOnDefault_;

    ImGuiWindow* backup_hovered_window = g.HoveredWindow;

    const bool flatten_hovered_children = (flags & ImGuiButtonFlags_FlattenChildren) && g.HoveredWindow && g.HoveredWindow->RootWindowDockTree == window->RootWindowDockTree;

    if (flatten_hovered_children)

        g.HoveredWindow = window;

#ifdef IMGUI_ENABLE_TEST_ENGINE

    // Alternate registration spot, for when caller didn't use ItemAdd()

    if (g.LastItemData.ID != id)

        IMGUI_TEST_ENGINE_ITEM_ADD(id, bb, NULL);

#endif

    bool pressed = false;

    bool hovered = ItemHoverable(bb, id, item_flags);

    // Special mode for Drag and Drop used by openables (tree nodes, tabs etc.)

    // where holding the button pressed for a long time while drag a payload item triggers the button.

    if (g.DragDropActive && (flags & ImGuiButtonFlags_PressedOnDragDropHold) && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoHoldToOpenOthers))

        if (IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))

        {

            hovered = true;

            SetHoveredID(id);

            if (g.HoveredIdTimer - g.IO.DeltaTime <= DRAGDROP_HOLD_TO_OPEN_TIMER && g.HoveredIdTimer >= DRAGDROP_HOLD_TO_OPEN_TIMER)

            {

                pressed = true;

                g.DragDropHoldJustPressedId = id;

                FocusWindow(window);

            }

        }

    if (flatten_hovered_children)

        g.HoveredWindow = backup_hovered_window;

    // Mouse handling

    const ImGuiID test_owner_id = (flags & ImGuiButtonFlags_NoTestKeyOwner) ? ImGuiKeyOwner_Any : id;

    if (hovered)

    {

        IM_ASSERT(id != 0); // Lazily check inside rare path.

        // Poll mouse buttons

        // - 'mouse_button_clicked' is generally carried into ActiveIdMouseButton when setting ActiveId.

        // - Technically we only need some values in one code path, but since this is gated by hovered test this is fine.

        int mouse_button_clicked = -1;

        int mouse_button_released = -1;

        for (int button = 0; button < 3; button++)

            if (flags & (ImGuiButtonFlags_MouseButtonLeft << button)) // Handle ImGuiButtonFlags_MouseButtonRight and ImGuiButtonFlags_MouseButtonMiddle here.

            {

                if (IsMouseClicked(button, ImGuiInputFlags_None, test_owner_id) && mouse_button_clicked == -1) { mouse_button_clicked = button; }

                if (IsMouseReleased(button, test_owner_id) && mouse_button_released == -1) { mouse_button_released = button; }

            }

        // Process initial action

        const bool mods_ok = !(flags & ImGuiButtonFlags_NoKeyModsAllowed) || (!g.IO.KeyCtrl && !g.IO.KeyShift && !g.IO.KeyAlt);

        if (mods_ok)

        {

            if (mouse_button_clicked != -1 && g.ActiveId != id)

            {

                if (!(flags & ImGuiButtonFlags_NoSetKeyOwner))

                    SetKeyOwner(MouseButtonToKey(mouse_button_clicked), id);

                if (flags & (ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere))

                {

                    SetActiveID(id, window);

                    g.ActiveIdMouseButton = mouse_button_clicked;

                    if (!(flags & ImGuiButtonFlags_NoNavFocus))

                    {

                        SetFocusID(id, window);

                        FocusWindow(window);

                    }

                    else if (!(flags & ImGuiButtonFlags_NoFocus))

                    {

                        FocusWindow(window, ImGuiFocusRequestFlags_RestoreFocusedChild); // Still need to focus and bring to front, but try to avoid losing NavId when navigating a child

                    }

                }

                if ((flags & ImGuiButtonFlags_PressedOnClick) || ((flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseClickedCount[mouse_button_clicked] == 2))

                {

                    pressed = true;

                    if (flags & ImGuiButtonFlags_NoHoldingActiveId)

                        ClearActiveID();

                    else

                        SetActiveID(id, window); // Hold on ID

                    g.ActiveIdMouseButton = mouse_button_clicked;

                    if (!(flags & ImGuiButtonFlags_NoNavFocus))

                    {

                        SetFocusID(id, window);

                        FocusWindow(window);

                    }

                    else if (!(flags & ImGuiButtonFlags_NoFocus))

                    {

                        FocusWindow(window, ImGuiFocusRequestFlags_RestoreFocusedChild); // Still need to focus and bring to front, but try to avoid losing NavId when navigating a child

                    }

                }

            }

            if (flags & ImGuiButtonFlags_PressedOnRelease)

            {

                if (mouse_button_released != -1)

                {

                    const bool has_repeated_at_least_once = (item_flags & ImGuiItemFlags_ButtonRepeat) && g.IO.MouseDownDurationPrev[mouse_button_released] >= g.IO.KeyRepeatDelay; // Repeat mode trumps on release behavior

                    if (!has_repeated_at_least_once)

                        pressed = true;

                    if (!(flags & ImGuiButtonFlags_NoNavFocus))

                        SetFocusID(id, window); // FIXME: Lack of FocusWindow() call here is inconsistent with other paths. Research why.

                    ClearActiveID();

                }

            }

            // 'Repeat' mode acts when held regardless of _PressedOn flags (see table above).

            // Relies on repeat logic of IsMouseClicked() but we may as well do it ourselves if we end up exposing finer RepeatDelay/RepeatRate settings.

            if (g.ActiveId == id && (item_flags & ImGuiItemFlags_ButtonRepeat))

                if (g.IO.MouseDownDuration[g.ActiveIdMouseButton] > 0.0f && IsMouseClicked(g.ActiveIdMouseButton, ImGuiInputFlags_Repeat, test_owner_id))

                    pressed = true;

        }

        if (pressed && g.IO.ConfigNavCursorVisibleAuto)

            g.NavCursorVisible = false;

    }

    // Keyboard/Gamepad navigation handling

    // We report navigated and navigation-activated items as hovered but we don't set g.HoveredId to not interfere with mouse.

    if (g.NavId == id && g.NavCursorVisible && g.NavHighlightItemUnderNav)

        if (!(flags & ImGuiButtonFlags_NoHoveredOnFocus))

            hovered = true;

    if (g.NavActivateDownId == id)

    {

        bool nav_activated_by_code = (g.NavActivateId == id);

        bool nav_activated_by_inputs = (g.NavActivatePressedId == id);

        if (!nav_activated_by_inputs && (item_flags & ImGuiItemFlags_ButtonRepeat))

        {

            // Avoid pressing multiple keys from triggering excessive amount of repeat events

            const ImGuiKeyData* key1 = GetKeyData(ImGuiKey_Space);

            const ImGuiKeyData* key2 = GetKeyData(ImGuiKey_Enter);

            const ImGuiKeyData* key3 = GetKeyData(ImGuiKey_NavGamepadActivate);

            const float t1 = ImMax(ImMax(key1->DownDuration, key2->DownDuration), key3->DownDuration);

            nav_activated_by_inputs = CalcTypematicRepeatAmount(t1 - g.IO.DeltaTime, t1, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate) > 0;

        }

        if (nav_activated_by_code || nav_activated_by_inputs)

        {

            // Set active id so it can be queried by user via IsItemActive(), equivalent of holding the mouse button.

            pressed = true;

            SetActiveID(id, window);

            g.ActiveIdSource = g.NavInputSource;

            if (!(flags & ImGuiButtonFlags_NoNavFocus) && !(g.NavActivateFlags & ImGuiActivateFlags_FromShortcut))

                SetFocusID(id, window);

            if (g.NavActivateFlags & ImGuiActivateFlags_FromShortcut)

                g.ActiveIdFromShortcut = true;

        }

    }

    // Process while held

    bool held = false;

    if (g.ActiveId == id)

    {

        if (g.ActiveIdSource == ImGuiInputSource_Mouse)

        {

            if (g.ActiveIdIsJustActivated)

                g.ActiveIdClickOffset = g.IO.MousePos - bb.Min;

            const int mouse_button = g.ActiveIdMouseButton;

            if (mouse_button == -1)

            {

                // Fallback for the rare situation were g.ActiveId was set programmatically or from another widget (e.g. #6304).

                ClearActiveID();

            }

            else if (IsMouseDown(mouse_button, test_owner_id))

            {

                held = true;

            }

            else

            {

                bool release_in = hovered && (flags & ImGuiButtonFlags_PressedOnClickRelease) != 0;

                bool release_anywhere = (flags & ImGuiButtonFlags_PressedOnClickReleaseAnywhere) != 0;

                if ((release_in || release_anywhere) && !g.DragDropActive)

                {

                    // Report as pressed when releasing the mouse (this is the most common path)

                    bool is_double_click_release = (flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseReleased[mouse_button] && g.IO.MouseClickedLastCount[mouse_button] == 2;

                    bool is_repeating_already = (item_flags & ImGuiItemFlags_ButtonRepeat) && g.IO.MouseDownDurationPrev[mouse_button] >= g.IO.KeyRepeatDelay; // Repeat mode trumps <on release>

                    bool is_button_avail_or_owned = TestKeyOwner(MouseButtonToKey(mouse_button), test_owner_id);

                    if (!is_double_click_release && !is_repeating_already && is_button_avail_or_owned)

                        pressed = true;

                }

                ClearActiveID();

            }

            if (!(flags & ImGuiButtonFlags_NoNavFocus) && g.IO.ConfigNavCursorVisibleAuto)

                g.NavCursorVisible = false;

        }

        else if (g.ActiveIdSource == ImGuiInputSource_Keyboard || g.ActiveIdSource == ImGuiInputSource_Gamepad)

        {

            // When activated using Nav, we hold on the ActiveID until activation button is released

            if (g.NavActivateDownId == id)

                held = true; // hovered == true not true as we are already likely hovered on direct activation.

            else

                ClearActiveID();

        }

        if (pressed)

            g.ActiveIdHasBeenPressedBefore = true;

    }

    // Activation highlight (this may be a remote activation)

    if (g.NavHighlightActivatedId == id)

        hovered = true;

    if (out_hovered) *out_hovered = hovered;

    if (out_held) *out_held = held;

    return pressed;

}

bool ImGui::ButtonEx(const char* label, const ImVec2& size_arg, ImGuiButtonFlags flags)

{

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return false;

    ImGuiContext& g = *GImGui;

    const ImGuiStyle& style = g.Style;

    const ImGuiID id = window->GetID(label);

    const ImVec2 label_size = CalcTextSize(label, NULL, true);

    ImVec2 pos = window->DC.CursorPos;

    if ((flags & ImGuiButtonFlags_AlignTextBaseLine) && style.FramePadding.y < window->DC.CurrLineTextBaseOffset) // Try to vertically align buttons that are smaller/have no padding so that text baseline matches (bit hacky, since it shouldn't be a flag)

        pos.y += window->DC.CurrLineTextBaseOffset - style.FramePadding.y;

    ImVec2 size = CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);

    const ImRect bb(pos, pos + size);

    ItemSize(size, style.FramePadding.y);

    if (!ItemAdd(bb, id))

        return false;

    bool hovered, held;

    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

    // Render

    const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);

    RenderNavCursor(bb, id);

    RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);

    if (g.LogEnabled)

        LogSetNextTextDecoration("[", "]");

    RenderTextClipped(bb.Min + style.FramePadding, bb.Max - style.FramePadding, label, NULL, &label_size, style.ButtonTextAlign, &bb);

    // Automatically close popups

    //if (pressed && !(flags & ImGuiButtonFlags_DontClosePopups) && (window->Flags & ImGuiWindowFlags_Popup))

    //    CloseCurrentPopup();

    IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags);

    return pressed;

}

bool ImGui::Button(const char* label, const ImVec2& size_arg)

{

    return ButtonEx(label, size_arg, ImGuiButtonFlags_None);

}

// Small buttons fits within text without additional vertical spacing.

bool ImGui::SmallButton(const char* label)

{

    ImGuiContext& g = *GImGui;

    float backup_padding_y = g.Style.FramePadding.y;

    g.Style.FramePadding.y = 0.0f;

    bool pressed = ButtonEx(label, ImVec2(0, 0), ImGuiButtonFlags_AlignTextBaseLine);

    g.Style.FramePadding.y = backup_padding_y;

    return pressed;

}

// Tip: use ImGui::PushID()/PopID() to push indices or pointers in the ID stack.

// Then you can keep 'str_id' empty or the same for all your buttons (instead of creating a string based on a non-string id)

bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg, ImGuiButtonFlags flags)

{

    ImGuiContext& g = *GImGui;

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return false;

    // Cannot use zero-size for InvisibleButton(). Unlike Button() there is not way to fallback using the label size.

    IM_ASSERT(size_arg.x != 0.0f && size_arg.y != 0.0f);

    const ImGuiID id = window->GetID(str_id);

    ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);

    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);

    ItemSize(size);

    if (!ItemAdd(bb, id, NULL, (flags & ImGuiButtonFlags_EnableNav) ? ImGuiItemFlags_None : ImGuiItemFlags_NoNav))

        return false;

    bool hovered, held;

    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

    RenderNavCursor(bb, id);

    IMGUI_TEST_ENGINE_ITEM_INFO(id, str_id, g.LastItemData.StatusFlags);

    return pressed;

}

bool ImGui::ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size, ImGuiButtonFlags flags)

{

    ImGuiContext& g = *GImGui;

    ImGuiWindow* window = GetCurrentWindow();

    if (window->SkipItems)

        return false;

    const ImGuiID id = window->GetID(str_id);

    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);

    const float default_size = GetFrameHeight();

    ItemSize(size, (size.y >= default_size) ? g.Style.FramePadding.y : -1.0f);

    if (!ItemAdd(bb, id))

        return false;

    bool hovered, held;

    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

    // Render

    const ImU32 bg_col = GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);

    const ImU32 text_col = GetColorU32(ImGuiCol_Text);

    RenderNavCursor(bb, id);

    RenderFrame(bb.Min, bb.Max, bg_col, true, g.Style.FrameRounding);

    RenderArrow(window->DrawList, bb.Min + ImVec2(ImMax(0.0f, (size.x - g.FontSize) * 0.5f), ImMax(0.0f, (size.y - g.FontSize) * 0.5f)), text_col, dir);

    IMGUI_TEST_ENGINE_ITEM_INFO(id, str_id, g.LastItemData.StatusFlags);

    return pressed;

}

bool ImGui::ArrowButton(const char* str_id, ImGuiDir dir)

{

    float sz = GetFrameHeight();

    return ArrowButtonEx(str_id, dir, ImVec2(sz, sz), ImGuiButtonFlags_None);

}

// Button to close a window

bool ImGui::CloseButton(ImGuiID id, const ImVec2& pos)

{

    ImGuiContext& g = *GImGui;

    ImGuiWindow* window = g.CurrentWindow;