// dear imgui, v1.74 WIP

// (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: 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

#include "imgui.h"

#ifndef IMGUI_DEFINE_MATH_OPERATORS

#define IMGUI_DEFINE_MATH_OPERATORS

#endif

#include "imgui_internal.h"

#include <ctype.h> // toupper

#if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier

#include <stddef.h> // intptr_t

#else

#include <stdint.h> // intptr_t

#endif

// 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

#endif

// Clang/GCC warnings with -Weverything

#if defined(__clang__)

#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-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 //

#if __has_warning("-Wzero-as-null-pointer-constant")

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

#endif

#if __has_warning("-Wdouble-promotion")

#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.

#endif

#elif defined(__GNUC__)

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

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

#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

#endif

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

// Data

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

// 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(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);

static int InputTextCalcTextLenAndLineCount(const char* text_begin, const char** out_text_end);

static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining = NULL, ImVec2* out_offset = NULL, bool stop_on_new_line = false);

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

// [SECTION] Widgets: Text, etc.

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

// - 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;

IM_ASSERT(text != NULL);

const char* text_begin = text;

if (text_end == NULL)

text_end = text + strlen(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)

{

// 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*)memchr(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, false))

break;

const char* line_end = (const char*)memchr(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*)memchr(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);

ItemAdd(bb, 0);

}

else

{

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);

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);

}

}

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;

ImGuiContext& g = *GImGui;

const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);

TextEx(g.TempBuffer, 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)

{

PushStyleColor(ImGuiCol_Text, GImGui->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)

{

ImGuiWindow* window = GetCurrentWindow();

bool need_backup = (window->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::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 ImVec2 label_size = CalcTextSize(label, NULL, true);

const ImRect value_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y + style.FramePadding.y*2));

const ImRect total_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + (label_size.x > 0.0f ? style.ItemInnerSpacing.x : 0.0f), style.FramePadding.y*2) + label_size);

ItemSize(total_bb, style.FramePadding.y);

if (!ItemAdd(total_bb, 0))

return;

// Render

const char* value_text_begin = &g.TempBuffer[0];

const char* value_text_end = value_text_begin + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);

RenderTextClipped(value_bb.Min, value_bb.Max, value_text_begin, value_text_end, NULL, ImVec2(0.0f,0.5f));

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 = g.TempBuffer;

const char* text_end = text_begin + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);

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

const float text_base_offset_y = ImMax(0.0f, window->DC.CurrLineTextBaseOffset); // Latch before ItemSize changes it

const float line_height = ImMax(ImMin(window->DC.CurrLineSize.y, g.FontSize + g.Style.FramePadding.y*2), g.FontSize);

const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(g.FontSize + (label_size.x > 0.0f ? (label_size.x + style.FramePadding.x*2) : 0.0f), ImMax(line_height, label_size.y))); // Empty text doesn't add padding

ItemSize(bb);

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, line_height*0.5f), text_col);

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

}

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

// [SECTION] Widgets: Main

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

// - ButtonBehavior() [Internal]

// - Button()

// - SmallButton()

// - InvisibleButton()

// - ArrowButton()

// - CloseButton() [Internal]

// - CollapseButton() [Internal]

// - ScrollbarEx() [Internal]

// - Scrollbar() [Internal]

// - Image()

// - ImageButton()

// - Checkbox()

// - CheckboxFlags()

// - RadioButton()

// - ProgressBar()

// - Bullet()

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

// 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 ImGuiButtonFlags_Repeat 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

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

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

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = GetCurrentWindow();

if (flags & ImGuiButtonFlags_Disabled)

{

if (out_hovered) *out_hovered = false;

if (out_held) *out_held = false;

if (g.ActiveId == id) ClearActiveID();

return false;

}

// Default behavior requires click+release on same spot

if ((flags & (ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick)) == 0)

flags |= ImGuiButtonFlags_PressedOnClickRelease;

ImGuiWindow* backup_hovered_window = g.HoveredWindow;

const bool flatten_hovered_children = (flags & ImGuiButtonFlags_FlattenChildren) && g.HoveredRootWindow == window;

if (flatten_hovered_children)

g.HoveredWindow = window;

#ifdef IMGUI_ENABLE_TEST_ENGINE

if (id != 0 && window->DC.LastItemId != id)

ImGuiTestEngineHook_ItemAdd(&g, bb, id);

#endif

bool pressed = false;

bool hovered = ItemHoverable(bb, id);

// Drag source doesn't report as hovered

if (hovered && g.DragDropActive && g.DragDropPayload.SourceId == id && !(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoDisableHover))

hovered = false;

// Special mode for Drag and Drop where holding button pressed for a long time while dragging another item triggers the button

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

if (IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))

{

hovered = true;

SetHoveredID(id);

if (CalcTypematicPressedRepeatAmount(g.HoveredIdTimer + 0.0001f, g.HoveredIdTimer + 0.0001f - g.IO.DeltaTime, 0.01f, 0.70f)) // FIXME: Our formula for CalcTypematicPressedRepeatAmount() is fishy

{

pressed = true;

FocusWindow(window);

}

}

if (flatten_hovered_children)

g.HoveredWindow = backup_hovered_window;

// AllowOverlap mode (rarely used) requires previous frame HoveredId to be null or to match. This allows using patterns where a later submitted widget overlaps a previous one.

if (hovered && (flags & ImGuiButtonFlags_AllowItemOverlap) && (g.HoveredIdPreviousFrame != id && g.HoveredIdPreviousFrame != 0))

hovered = false;

// Mouse

if (hovered)

{

if (!(flags & ImGuiButtonFlags_NoKeyModifiers) || (!g.IO.KeyCtrl && !g.IO.KeyShift && !g.IO.KeyAlt))

{

if ((flags & ImGuiButtonFlags_PressedOnClickRelease) && g.IO.MouseClicked[0])

{

SetActiveID(id, window);

if (!(flags & ImGuiButtonFlags_NoNavFocus))

SetFocusID(id, window);

FocusWindow(window);

}

if (((flags & ImGuiButtonFlags_PressedOnClick) && g.IO.MouseClicked[0]) || ((flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseDoubleClicked[0]))

{

pressed = true;

if (flags & ImGuiButtonFlags_NoHoldingActiveID)

ClearActiveID();

else

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

FocusWindow(window);

}

if ((flags & ImGuiButtonFlags_PressedOnRelease) && g.IO.MouseReleased[0])

{

if (!((flags & ImGuiButtonFlags_Repeat) && g.IO.MouseDownDurationPrev[0] >= g.IO.KeyRepeatDelay)) // Repeat mode trumps <on release>

pressed = true;

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 ((flags & ImGuiButtonFlags_Repeat) && g.ActiveId == id && g.IO.MouseDownDuration[0] > 0.0f && IsMouseClicked(0, true))

pressed = true;

}

if (pressed)

g.NavDisableHighlight = true;

}

// Gamepad/Keyboard navigation

// We report navigated item as hovered but we don't set g.HoveredId to not interfere with mouse.

if (g.NavId == id && !g.NavDisableHighlight && g.NavDisableMouseHover && (g.ActiveId == 0 || g.ActiveId == id || g.ActiveId == window->MoveId))

if (!(flags & ImGuiButtonFlags_NoHoveredOnNav))

hovered = true;

if (g.NavActivateDownId == id)

{

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

bool nav_activated_by_inputs = IsNavInputPressed(ImGuiNavInput_Activate, (flags & ImGuiButtonFlags_Repeat) ? ImGuiInputReadMode_Repeat : ImGuiInputReadMode_Pressed);

if (nav_activated_by_code || nav_activated_by_inputs)

pressed = true;

if (nav_activated_by_code || nav_activated_by_inputs || g.ActiveId == id)

{

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

g.NavActivateId = id; // This is so SetActiveId assign a Nav source

SetActiveID(id, window);

if ((nav_activated_by_code || nav_activated_by_inputs) && !(flags & ImGuiButtonFlags_NoNavFocus))

SetFocusID(id, window);

}

}

bool held = false;

if (g.ActiveId == id)

{

if (pressed)

g.ActiveIdHasBeenPressedBefore = true;

if (g.ActiveIdSource == ImGuiInputSource_Mouse)

{

if (g.ActiveIdIsJustActivated)

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

if (g.IO.MouseDown[0])

{

held = true;

}

else

{

if (hovered && (flags & ImGuiButtonFlags_PressedOnClickRelease) && !g.DragDropActive)

{

bool is_double_click_release = (flags & ImGuiButtonFlags_PressedOnDoubleClick) && g.IO.MouseDownWasDoubleClick[0];

bool is_repeating_already = (flags & ImGuiButtonFlags_Repeat) && g.IO.MouseDownDurationPrev[0] >= g.IO.KeyRepeatDelay; // Repeat mode trumps <on release>

if (!is_double_click_release && !is_repeating_already)

pressed = true;

}

ClearActiveID();

}

if (!(flags & ImGuiButtonFlags_NoNavFocus))

g.NavDisableHighlight = true;

}

else if (g.ActiveIdSource == ImGuiInputSource_Nav)

{

if (g.NavActivateDownId != id)

ClearActiveID();

}

}

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;

if (window->DC.ItemFlags & ImGuiItemFlags_ButtonRepeat)

flags |= ImGuiButtonFlags_Repeat;

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);

RenderNavHighlight(bb, id);

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

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, window->DC.LastItemStatusFlags);

return pressed;

}

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

{

return ButtonEx(label, size_arg, 0);

}

// 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)

{

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))

return false;

bool hovered, held;

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

return pressed;

}

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

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return false;

ImGuiContext& g = *GImGui;

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 : 0.0f);

if (!ItemAdd(bb, id))

return false;

if (window->DC.ItemFlags & ImGuiItemFlags_ButtonRepeat)

flags |= ImGuiButtonFlags_Repeat;

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);

RenderNavHighlight(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);

return pressed;

}

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

{

float sz = GetFrameHeight();

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

}

// Button to close a window

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

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

// We intentionally allow interaction when clipped so that a mechanical Alt,Right,Validate sequence close a window.

// (this isn't the regular behavior of buttons, but it doesn't affect the user much because navigation tends to keep items visible).

const ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize) + g.Style.FramePadding * 2.0f);

bool is_clipped = !ItemAdd(bb, id);

bool hovered, held;

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

if (is_clipped)

return pressed;

// Render

ImU32 col = GetColorU32(held ? ImGuiCol_ButtonActive : ImGuiCol_ButtonHovered);

ImVec2 center = bb.GetCenter();

if (hovered)

window->DrawList->AddCircleFilled(center, ImMax(2.0f, g.FontSize * 0.5f + 1.0f), col, 12);

float cross_extent = g.FontSize * 0.5f * 0.7071f - 1.0f;

ImU32 cross_col = GetColorU32(ImGuiCol_Text);

center -= ImVec2(0.5f, 0.5f);

window->DrawList->AddLine(center + ImVec2(+cross_extent,+cross_extent), center + ImVec2(-cross_extent,-cross_extent), cross_col, 1.0f);

window->DrawList->AddLine(center + ImVec2(+cross_extent,-cross_extent), center + ImVec2(-cross_extent,+cross_extent), cross_col, 1.0f);

return pressed;

}

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

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

ImRect bb(pos, pos + ImVec2(g.FontSize, g.FontSize) + g.Style.FramePadding * 2.0f);

ItemAdd(bb, id);

bool hovered, held;

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

// Render

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

ImU32 text_col = GetColorU32(ImGuiCol_Text);

ImVec2 center = bb.GetCenter();

if (hovered || held)

window->DrawList->AddCircleFilled(center/*+ ImVec2(0.0f, -0.5f)*/, g.FontSize * 0.5f + 1.0f, bg_col, 12);

RenderArrow(window->DrawList, bb.Min + g.Style.FramePadding, text_col, window->Collapsed ? ImGuiDir_Right : ImGuiDir_Down, 1.0f);

// Switch to moving the window after mouse is moved beyond the initial drag threshold

if (IsItemActive() && IsMouseDragging())

StartMouseMovingWindow(window);

return pressed;

}

ImGuiID ImGui::GetScrollbarID(ImGuiWindow* window, ImGuiAxis axis)

{

return window->GetIDNoKeepAlive(axis == ImGuiAxis_X ? "#SCROLLX" : "#SCROLLY");

}

// Vertical/Horizontal scrollbar

// The entire piece of code below is rather confusing because:

// - We handle absolute seeking (when first clicking outside the grab) and relative manipulation (afterward or when clicking inside the grab)

// - We store values as normalized ratio and in a form that allows the window content to change while we are holding on a scrollbar

// - We handle both horizontal and vertical scrollbars, which makes the terminology not ideal.

// Still, the code should probably be made simpler..

bool ImGui::ScrollbarEx(const ImRect& bb_frame, ImGuiID id, ImGuiAxis axis, float* p_scroll_v, float size_avail_v, float size_contents_v, ImDrawCornerFlags rounding_corners)

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

if (window->SkipItems)

return false;

const float bb_frame_width = bb_frame.GetWidth();

const float bb_frame_height = bb_frame.GetHeight();

if (bb_frame_width <= 0.0f || bb_frame_height <= 0.0f)

return false;

// When we are too small, start hiding and disabling the grab (this reduce visual noise on very small window and facilitate using the resize grab)

float alpha = 1.0f;

if ((axis == ImGuiAxis_Y) && bb_frame_height < g.FontSize + g.Style.FramePadding.y * 2.0f)

alpha = ImSaturate((bb_frame_height - g.FontSize) / (g.Style.FramePadding.y * 2.0f));

if (alpha <= 0.0f)

return false;

const ImGuiStyle& style = g.Style;

const bool allow_interaction = (alpha >= 1.0f);

const bool horizontal = (axis == ImGuiAxis_X);

ImRect bb = bb_frame;

bb.Expand(ImVec2(-ImClamp((float)(int)((bb_frame_width - 2.0f) * 0.5f), 0.0f, 3.0f), -ImClamp((float)(int)((bb_frame_height - 2.0f) * 0.5f), 0.0f, 3.0f)));

// V denote the main, longer axis of the scrollbar (= height for a vertical scrollbar)

const float scrollbar_size_v = horizontal ? bb.GetWidth() : bb.GetHeight();

// Calculate the height of our grabbable box. It generally represent the amount visible (vs the total scrollable amount)

// But we maintain a minimum size in pixel to allow for the user to still aim inside.

IM_ASSERT(ImMax(size_contents_v, size_avail_v) > 0.0f); // Adding this assert to check if the ImMax(XXX,1.0f) is still needed. PLEASE CONTACT ME if this triggers.

const float win_size_v = ImMax(ImMax(size_contents_v, size_avail_v), 1.0f);

const float grab_h_pixels = ImClamp(scrollbar_size_v * (size_avail_v / win_size_v), style.GrabMinSize, scrollbar_size_v);

const float grab_h_norm = grab_h_pixels / scrollbar_size_v;

// Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().

bool held = false;

bool hovered = false;

ButtonBehavior(bb, id, &hovered, &held, ImGuiButtonFlags_NoNavFocus);

float scroll_max = ImMax(1.0f, size_contents_v - size_avail_v);

float scroll_ratio = ImSaturate(*p_scroll_v / scroll_max);

float grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;

if (held && allow_interaction && grab_h_norm < 1.0f)

{

float scrollbar_pos_v = horizontal ? bb.Min.x : bb.Min.y;

float mouse_pos_v = horizontal ? g.IO.MousePos.x : g.IO.MousePos.y;

// Click position in scrollbar normalized space (0.0f->1.0f)

const float clicked_v_norm = ImSaturate((mouse_pos_v - scrollbar_pos_v) / scrollbar_size_v);

SetHoveredID(id);

bool seek_absolute = false;

if (g.ActiveIdIsJustActivated)

{

// On initial click calculate the distance between mouse and the center of the grab

seek_absolute = (clicked_v_norm < grab_v_norm || clicked_v_norm > grab_v_norm + grab_h_norm);

if (seek_absolute)

g.ScrollbarClickDeltaToGrabCenter = 0.0f;

else

g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;

}

// Apply scroll

// It is ok to modify Scroll here because we are being called in Begin() after the calculation of ContentSize and before setting up our starting position

const float scroll_v_norm = ImSaturate((clicked_v_norm - g.ScrollbarClickDeltaToGrabCenter - grab_h_norm * 0.5f) / (1.0f - grab_h_norm));

*p_scroll_v = (float)(int)(0.5f + scroll_v_norm * scroll_max);//(win_size_contents_v - win_size_v));

// Update values for rendering

scroll_ratio = ImSaturate(*p_scroll_v / scroll_max);

grab_v_norm = scroll_ratio * (scrollbar_size_v - grab_h_pixels) / scrollbar_size_v;

// Update distance to grab now that we have seeked and saturated

if (seek_absolute)

g.ScrollbarClickDeltaToGrabCenter = clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f;

}

// Render

window->DrawList->AddRectFilled(bb_frame.Min, bb_frame.Max, GetColorU32(ImGuiCol_ScrollbarBg), window->WindowRounding, rounding_corners);

const ImU32 grab_col = GetColorU32(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab, alpha);

ImRect grab_rect;

if (horizontal)

grab_rect = ImRect(ImLerp(bb.Min.x, bb.Max.x, grab_v_norm), bb.Min.y, ImLerp(bb.Min.x, bb.Max.x, grab_v_norm) + grab_h_pixels, bb.Max.y);

else

grab_rect = ImRect(bb.Min.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm), bb.Max.x, ImLerp(bb.Min.y, bb.Max.y, grab_v_norm) + grab_h_pixels);

window->DrawList->AddRectFilled(grab_rect.Min, grab_rect.Max, grab_col, style.ScrollbarRounding);

return held;

}

void ImGui::Scrollbar(ImGuiAxis axis)

{

ImGuiContext& g = *GImGui;

ImGuiWindow* window = g.CurrentWindow;

const ImGuiID id = GetScrollbarID(window, axis);

KeepAliveID(id);

// Calculate scrollbar bounding box

const ImRect outer_rect = window->Rect();

const ImRect inner_rect = window->InnerRect;

const float border_size = window->WindowBorderSize;

const float scrollbar_size = window->ScrollbarSizes[axis ^ 1];

IM_ASSERT(scrollbar_size > 0.0f);

const float other_scrollbar_size = window->ScrollbarSizes[axis];

ImDrawCornerFlags rounding_corners = (other_scrollbar_size <= 0.0f) ? ImDrawCornerFlags_BotRight : 0;

ImRect bb;

if (axis == ImGuiAxis_X)

{

bb.Min = ImVec2(inner_rect.Min.x, ImMax(outer_rect.Min.y, outer_rect.Max.y - border_size - scrollbar_size));

bb.Max = ImVec2(inner_rect.Max.x, outer_rect.Max.y);

rounding_corners |= ImDrawCornerFlags_BotLeft;

}

else

{

bb.Min = ImVec2(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y);

bb.Max = ImVec2(outer_rect.Max.x, window->InnerRect.Max.y);

rounding_corners |= ((window->Flags & ImGuiWindowFlags_NoTitleBar) && !(window->Flags & ImGuiWindowFlags_MenuBar)) ? ImDrawCornerFlags_TopRight : 0;

}

ScrollbarEx(bb, id, axis, &window->Scroll[axis], inner_rect.Max[axis] - inner_rect.Min[axis], window->ContentSize[axis] + window->WindowPadding[axis] * 2.0f, rounding_corners);

}

void ImGui::Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& tint_col, const ImVec4& border_col)

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return;

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

if (border_col.w > 0.0f)

bb.Max += ImVec2(2, 2);

ItemSize(bb);

if (!ItemAdd(bb, 0))

return;

if (border_col.w > 0.0f)

{

window->DrawList->AddRect(bb.Min, bb.Max, GetColorU32(border_col), 0.0f);

window->DrawList->AddImage(user_texture_id, bb.Min + ImVec2(1, 1), bb.Max - ImVec2(1, 1), uv0, uv1, GetColorU32(tint_col));

}

else

{

window->DrawList->AddImage(user_texture_id, bb.Min, bb.Max, uv0, uv1, GetColorU32(tint_col));

}

}

// frame_padding < 0: uses FramePadding from style (default)

// frame_padding = 0: no framing

// frame_padding > 0: set framing size

// The color used are the button colors.

bool ImGui::ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col)

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return false;

ImGuiContext& g = *GImGui;

const ImGuiStyle& style = g.Style;

// Default to using texture ID as ID. User can still push string/integer prefixes.

// We could hash the size/uv to create a unique ID but that would prevent the user from animating UV.

PushID((void*)(intptr_t)user_texture_id);

const ImGuiID id = window->GetID("#image");

PopID();

const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float)frame_padding, (float)frame_padding) : style.FramePadding;

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

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

ItemSize(bb);

if (!ItemAdd(bb, id))

return false;

bool hovered, held;

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

// Render

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

RenderNavHighlight(bb, id);

RenderFrame(bb.Min, bb.Max, col, true, ImClamp((float)ImMin(padding.x, padding.y), 0.0f, style.FrameRounding));

if (bg_col.w > 0.0f)

window->DrawList->AddRectFilled(image_bb.Min, image_bb.Max, GetColorU32(bg_col));

window->DrawList->AddImage(user_texture_id, image_bb.Min, image_bb.Max, uv0, uv1, GetColorU32(tint_col));

return pressed;

}

bool ImGui::Checkbox(const char* label, bool* v)

{

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);

const float square_sz = GetFrameHeight();

const ImVec2 pos = window->DC.CursorPos;

const ImRect total_bb(pos, pos + ImVec2(square_sz + (label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f), label_size.y + style.FramePadding.y * 2.0f));

ItemSize(total_bb, style.FramePadding.y);

if (!ItemAdd(total_bb, id))

return false;

bool hovered, held;

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

if (pressed)

{

*v = !(*v);

MarkItemEdited(id);

}

const ImRect check_bb(pos, pos + ImVec2(square_sz, square_sz));

RenderNavHighlight(total_bb, id);