pwmgr

// dear imgui, v1.91.5

// [SECTION] Widgets: Box-Select support

// [SECTION] Widgets: Multi-Select helpers

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

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

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

static ImVec2 InputTextCalcTextSize(ImGuiContext* ctx, const char* text_begin, const char* text_end, const char** remaining = NULL, ImVec2* out_offset = NULL, bool stop_on_new_line = false);

// - Hyperlink()

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

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

flags |= ImGuiButtonFlags_MouseButtonLeft;

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

if (g.LastItemData.ID != id)

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

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

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

if (mods_ok)

{

FocusWindow(window);

}

else

{

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

}

g.ActiveIdMouseButton = mouse_button_clicked;

{

FocusWindow(window);

}

else

{

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

}

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

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

if (pressed && g.IO.ConfigNavCursorVisibleAuto)

g.NavCursorVisible = false;

// Keyboard/Gamepad navigation handling

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

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

g.NavCursorVisible = false;

RenderNavCursor(bb, id);

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

RenderNavCursor(bb, id);

RenderNavCursor(bb, id);

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

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

RenderNavCursor(bb, id, ImGuiNavRenderCursorFlags_Compact);

ImVec2 cross_center = bb.GetCenter() - ImVec2(0.5f, 0.5f);

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

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

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

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

RenderNavCursor(bb, id, ImGuiNavRenderCursorFlags_Compact);

float size_visible = window->InnerRect.Max[axis] - window->InnerRect.Min[axis];

ScrollbarEx(bb, id, axis, &scroll, (ImS64)size_visible, (ImS64)size_contents, rounding_corners);

bool ImGui::ScrollbarEx(const ImRect& bb_frame, ImGuiID id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 size_visible_v, ImS64 size_contents_v, ImDrawFlags flags)

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

const ImS64 win_size_v = ImMax(ImMax(size_contents_v, size_visible_v), (ImS64)1);

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

const ImS64 scroll_max = ImMax((ImS64)1, size_contents_v - size_visible_v);

const int held_dir = (clicked_v_norm < grab_v_norm) ? -1 : (clicked_v_norm > grab_v_norm + grab_h_norm) ? +1 : 0;

// On initial click when held_dir == 0 (clicked over grab): calculate the distance between mouse and the center of the grab

const bool scroll_to_clicked_location = (g.IO.ConfigScrollbarScrollByPage == false || g.IO.KeyShift || held_dir == 0);

g.ScrollbarSeekMode = scroll_to_clicked_location ? 0 : (short)held_dir;

g.ScrollbarClickDeltaToGrabCenter = (held_dir == 0 && !g.IO.KeyShift) ? clicked_v_norm - grab_v_norm - grab_h_norm * 0.5f : 0.0f;

if (g.ScrollbarSeekMode == 0)

{

// Absolute seeking

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

*p_scroll_v = (ImS64)(scroll_v_norm * scroll_max);

}

else

{

// Page by page

if (IsMouseClicked(ImGuiMouseButton_Left, ImGuiInputFlags_Repeat) && held_dir == g.ScrollbarSeekMode)

{

float page_dir = (g.ScrollbarSeekMode > 0.0f) ? +1.0f : -1.0f;

*p_scroll_v = ImClamp(*p_scroll_v + (ImS64)(page_dir * size_visible_v), (ImS64)0, scroll_max);

}

}

// Update distance to grab now that we have seek'ed and saturated

//if (seek_absolute)

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

RenderNavCursor(bb, id);

// - old ImageButton() used ImTextureId as item id (created issue with multiple buttons with same image, transient texture id values, opaque computation of ID)

// - new ImageButton() requires an explicit 'const char* str_id'

// - old ImageButton() had frame_padding' override argument.

// - new ImageButton() always use style.FramePadding.

/*

PushID((ImTextureID)(intptr_t)user_texture_id);

bool ret = ImageButton("", user_texture_id, size, uv0, uv1, bg_col, tint_col);

PopID();

*/

const bool is_visible = ItemAdd(total_bb, id);

const bool is_multi_select = (g.LastItemData.ItemFlags & ImGuiItemFlags_IsMultiSelect) != 0;

if (!is_visible)

if (!is_multi_select || !g.BoxSelectState.UnclipMode || !g.BoxSelectState.UnclipRect.Overlaps(total_bb)) // Extra layer of "no logic clip" for box-select support

{

IMGUI_TEST_ENGINE_ITEM_INFO(id, label, g.LastItemData.StatusFlags | ImGuiItemStatusFlags_Checkable | (*v ? ImGuiItemStatusFlags_Checked : 0));

return false;

}

// Range-Selection/Multi-selection support (header)

bool checked = *v;

if (is_multi_select)

MultiSelectItemHeader(id, &checked, NULL);

// Range-Selection/Multi-selection support (footer)

if (is_multi_select)

MultiSelectItemFooter(id, &checked, &pressed);

else if (pressed)

checked = !checked;

if (*v != checked)

*v = checked;

pressed = true; // return value

const bool mixed_value = (g.LastItemData.ItemFlags & ImGuiItemFlags_MixedValue) != 0;

if (is_visible)

RenderNavCursor(total_bb, id);

RenderFrame(check_bb.Min, check_bb.Max, GetColorU32((held && hovered) ? ImGuiCol_FrameBgActive : hovered ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg), true, style.FrameRounding);

ImU32 check_col = GetColorU32(ImGuiCol_CheckMark);

if (mixed_value)

{

// Undocumented tristate/mixed/indeterminate checkbox (#2644)

// This may seem awkwardly designed because the aim is to make ImGuiItemFlags_MixedValue supported by all widgets (not just checkbox)

ImVec2 pad(ImMax(1.0f, IM_TRUNC(square_sz / 3.6f)), ImMax(1.0f, IM_TRUNC(square_sz / 3.6f)));

window->DrawList->AddRectFilled(check_bb.Min + pad, check_bb.Max - pad, check_col, style.FrameRounding);

}

else if (*v)

{

const float pad = ImMax(1.0f, IM_TRUNC(square_sz / 6.0f));

RenderCheckMark(window->DrawList, check_bb.Min + ImVec2(pad, pad), check_col, square_sz - pad * 2.0f);

}

const ImVec2 label_pos = ImVec2(check_bb.Max.x + style.ItemInnerSpacing.x, check_bb.Min.y + style.FramePadding.y);

if (is_visible && label_size.x > 0.0f)

RenderNavCursor(total_bb, id);

// Fraction < 0.0f will display an indeterminate progress bar animation

// The value must be animated along with time, so e.g. passing '-1.0f * ImGui::GetTime()' as fraction works.

const bool is_indeterminate = (fraction < 0.0f);

if (!is_indeterminate)

fraction = ImSaturate(fraction);

// Out of courtesy we accept a NaN fraction without crashing

float fill_n0 = 0.0f;

float fill_n1 = (fraction == fraction) ? fraction : 0.0f;

if (is_indeterminate)

{

const float fill_width_n = 0.2f;

fill_n0 = ImFmod(-fraction, 1.0f) * (1.0f + fill_width_n) - fill_width_n;

fill_n1 = ImSaturate(fill_n0 + fill_width_n);

fill_n0 = ImSaturate(fill_n0);

}

RenderRectFilledRangeH(window->DrawList, bb, GetColorU32(ImGuiCol_PlotHistogram), fill_n0, fill_n1, style.FrameRounding);

// Don't display text for indeterminate bars by default

if (!is_indeterminate || overlay != NULL)

if (!overlay)

{

ImFormatString(overlay_buf, IM_ARRAYSIZE(overlay_buf), "%.0f%%", fraction * 100 + 0.01f);

overlay = overlay_buf;

}

ImVec2 overlay_size = CalcTextSize(overlay, NULL);

if (overlay_size.x > 0.0f)

{

float text_x = is_indeterminate ? (bb.Min.x + bb.Max.x - overlay_size.x) * 0.5f : ImLerp(bb.Min.x, bb.Max.x, fill_n1) + style.ItemSpacing.x;

RenderTextClipped(ImVec2(ImClamp(text_x, bb.Min.x, bb.Max.x - overlay_size.x - style.ItemInnerSpacing.x), bb.Min.y), bb.Max, overlay, NULL, &overlay_size, ImVec2(0.0f, 0.5f), &bb);

}

}

// This is provided as a convenience for being an often requested feature.

// FIXME-STYLE: we delayed adding as there is a larger plan to revamp the styling system.

// Because of this we currently don't provide many styling options for this widget

// (e.g. hovered/active colors are automatically inferred from a single color).

bool ImGui::TextLink(const char* label)

{

ImGuiWindow* window = GetCurrentWindow();

if (window->SkipItems)

return false;

ImGuiContext& g = *GImGui;

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

const char* label_end = FindRenderedTextEnd(label);

ImVec2 pos = window->DC.CursorPos;

ImVec2 size = CalcTextSize(label, label_end, true);

ImRect bb(pos, pos + size);

ItemSize(size, 0.0f);

if (!ItemAdd(bb, id))

return false;

bool hovered, held;

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

RenderNavCursor(bb, id);

if (hovered)

SetMouseCursor(ImGuiMouseCursor_Hand);

ImVec4 text_colf = g.Style.Colors[ImGuiCol_TextLink];

ImVec4 line_colf = text_colf;

{

// FIXME-STYLE: Read comments above. This widget is NOT written in the same style as some earlier widgets,

// as we are currently experimenting/planning a different styling system.

float h, s, v;

ColorConvertRGBtoHSV(text_colf.x, text_colf.y, text_colf.z, h, s, v);

if (held || hovered)

{

v = ImSaturate(v + (held ? 0.4f : 0.3f));

h = ImFmod(h + 0.02f, 1.0f);

}

ColorConvertHSVtoRGB(h, s, v, text_colf.x, text_colf.y, text_colf.z);

v = ImSaturate(v - 0.20f);

ColorConvertHSVtoRGB(h, s, v, line_colf.x, line_colf.y, line_colf.z);

}

float line_y = bb.Max.y + ImFloor(g.Font->Descent * g.FontScale * 0.20f);

window->DrawList->AddLine(ImVec2(bb.Min.x, line_y), ImVec2(bb.Max.x, line_y), GetColorU32(line_colf)); // FIXME-TEXT: Underline mode.

PushStyleColor(ImGuiCol_Text, GetColorU32(text_colf));

RenderText(bb.Min, label, label_end);

PopStyleColor();

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

return pressed;

}

void ImGui::TextLinkOpenURL(const char* label, const char* url)

{

ImGuiContext& g = *GImGui;

if (url == NULL)

url = label;

if (TextLink(label))

if (g.PlatformIO.Platform_OpenInShellFn != NULL)

g.PlatformIO.Platform_OpenInShellFn(&g, url);

SetItemTooltip(LocalizeGetMsg(ImGuiLocKey_OpenLink_s), url); // It is more reassuring for user to _always_ display URL when we same as label

if (BeginPopupContextItem())

{

if (MenuItem(LocalizeGetMsg(ImGuiLocKey_CopyLink)))

SetClipboardText(url);

EndPopup();

}

}

RenderNavCursor(bb, id);

ImFormatString(name, IM_ARRAYSIZE(name), "##Combo_%02d", g.BeginComboDepth); // Recycle windows based on depth

PushStyleVarX(ImGuiStyleVar_WindowPadding, g.Style.FramePadding.x); // Horizontally align ourselves with the framed text

g.BeginComboDepth++;

ImGuiContext& g = *GImGui;

g.BeginComboDepth--;

ImGuiListClipper clipper;

clipper.Begin(items_count);

clipper.IncludeItemByIndex(*current_item);

while (clipper.Step())

for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)

const char* item_text = getter(user_data, i);

if (item_text == NULL)

item_text = "*Unknown item*";

PushID(i);

const bool item_selected = (i == *current_item);

if (Selectable(item_text, item_selected) && *current_item != i)

{

value_changed = true;

*current_item = i;

}

if (item_selected)

SetItemDefaultFocus();

PopID();

// - DataTypeApplyFromText()

{ sizeof(bool), "bool", "%d", "%d" }, // ImGuiDataType_Bool

bool ImGui::DataTypeApplyFromText(const char* buf, ImGuiDataType data_type, void* p_data, const char* format, void* p_data_when_empty)

// Copy the value in an opaque buffer so we can compare at the end of the function if it changed at all.

const ImGuiDataTypeInfo* type_info = DataTypeGetInfo(data_type);

ImGuiDataTypeStorage data_backup;

memcpy(&data_backup, p_data, type_info->Size);

{

if (p_data_when_empty != NULL)

{

memcpy(p_data, p_data_when_empty, type_info->Size);

return memcmp(&data_backup, p_data, type_info->Size) != 0;

}

}

bool ImGui::DataTypeIsZero(ImGuiDataType data_type, const void* p_data)

{

ImGuiContext& g = *GImGui;

return DataTypeCompare(data_type, p_data, &g.DataTypeZeroValue) == 0;

}

const bool is_bounded = (v_min < v_max) || ((v_min == v_max) && (v_min != 0.0f || (flags & ImGuiSliderFlags_ClampZeroRange)));

const bool is_wrapped = is_bounded && (flags & ImGuiSliderFlags_WrapAround);

if (v_speed == 0.0f && is_bounded && (v_max - v_min < FLT_MAX))

const float tweak_factor = tweak_slow ? 1.0f / 10.0f : tweak_fast ? 10.0f : 1.0f;

const bool is_just_activated = g.ActiveIdIsJustActivated;

const bool is_already_past_limits_and_pushing_outward = is_bounded && !is_wrapped && ((*v >= v_max && adjust_delta > 0.0f) || (*v <= v_min && adjust_delta < 0.0f));

if (*v != v_cur && is_bounded)

if (is_wrapped)

{

// Wrap values

if (v_cur < v_min)

v_cur += v_max - v_min + (is_floating_point ? 0 : 1);

if (v_cur > v_max)

v_cur -= v_max - v_min + (is_floating_point ? 0 : 1);

}

else

{

// Clamp values + handle overflow/wrap-around for integer types.

if (v_cur < v_min || (v_cur > *v && adjust_delta < 0.0f && !is_floating_point))

v_cur = v_min;

if (v_cur > v_max || (v_cur < *v && adjust_delta > 0.0f && !is_floating_point))

v_cur = v_max;

}

IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_InvalidMask_) == 0) && "Invalid ImGuiSliderFlags flags! Has the legacy 'float power' argument been mistakenly cast to flags? Call function with ImGuiSliderFlags_Logarithmic flags instead.");

if ((g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly))

const bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags);

const bool clicked = hovered && IsMouseClicked(0, ImGuiInputFlags_None, id);

// Only clamp CTRL+Click input when ImGuiSliderFlags_ClampOnInput is set (generally via ImGuiSliderFlags_AlwaysClamp)

bool clamp_enabled = false;

if ((flags & ImGuiSliderFlags_ClampOnInput) && (p_min != NULL || p_max != NULL))

{

const int clamp_range_dir = (p_min != NULL && p_max != NULL) ? DataTypeCompare(data_type, p_min, p_max) : 0; // -1 when *p_min < *p_max, == 0 when *p_min == *p_max

if (p_min == NULL || p_max == NULL || clamp_range_dir < 0)

clamp_enabled = true;

else if (clamp_range_dir == 0)

clamp_enabled = DataTypeIsZero(data_type, p_min) ? ((flags & ImGuiSliderFlags_ClampZeroRange) != 0) : true;

}

return TempInputScalar(frame_bb, id, label, data_type, p_data, format, clamp_enabled ? p_min : NULL, clamp_enabled ? p_max : NULL);

RenderNavCursor(frame_bb, id);

input_delta /= 100.0f; // Keyboard/Gamepad tweak speeds in % of slider bounds

input_delta = ((input_delta < 0.0f) ? -1.0f : +1.0f) / v_range_f; // Keyboard/Gamepad tweak speeds in integer steps

if ((g.LastItemData.ItemFlags & ImGuiItemFlags_ReadOnly) || (flags & ImGuiSliderFlags_ReadOnly))

IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_InvalidMask_) == 0) && "Invalid ImGuiSliderFlags flags! Has the legacy 'float power' argument been mistakenly cast to flags? Call function with ImGuiSliderFlags_Logarithmic flags instead.");

IM_ASSERT((flags & ImGuiSliderFlags_WrapAround) == 0); // Not supported by SliderXXX(), only by DragXXX()

const bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags);

const bool clicked = hovered && IsMouseClicked(0, ImGuiInputFlags_None, id);

// Only clamp CTRL+Click input when ImGuiSliderFlags_ClampOnInput is set (generally via ImGuiSliderFlags_AlwaysClamp)

const bool clamp_enabled = (flags & ImGuiSliderFlags_ClampOnInput) != 0;

return TempInputScalar(frame_bb, id, label, data_type, p_data, format, clamp_enabled ? p_min : NULL, clamp_enabled ? p_max : NULL);

RenderNavCursor(frame_bb, id);

const bool hovered = ItemHoverable(frame_bb, id, g.LastItemData.ItemFlags);

const bool clicked = hovered && IsMouseClicked(0, ImGuiInputFlags_None, id);

RenderNavCursor(frame_bb, id);

// FIXME: Among other things, setting ImGuiItemFlags_AllowDuplicateId in LastItemData is currently correct but

// the expected relationship between TempInputXXX functions and LastItemData is a little fishy.

g.LastItemData.ItemFlags |= ImGuiItemFlags_AllowDuplicateId;

ImGuiContext& g = *GImGui;

ImGuiInputTextFlags flags = ImGuiInputTextFlags_AutoSelectAll | (ImGuiInputTextFlags)ImGuiInputTextFlags_LocalizeDecimalPoint;

g.LastItemData.ItemFlags |= ImGuiItemFlags_NoMarkEdited; // Because TempInputText() uses ImGuiInputTextFlags_MergedItem it doesn't submit a new item, so we poke LastItemData.

ImGuiDataTypeStorage data_backup;

DataTypeApplyFromText(data_buf, data_type, p_data, format, NULL);

g.LastItemData.ItemFlags &= ~ImGuiItemFlags_NoMarkEdited;

void ImGui::SetNextItemRefVal(ImGuiDataType data_type, void* p_data)

{

ImGuiContext& g = *GImGui;

g.NextItemData.HasFlags |= ImGuiNextItemDataFlags_HasRefVal;

memcpy(&g.NextItemData.RefVal, p_data, DataTypeGetInfo(data_type)->Size);

}

IM_ASSERT((flags & ImGuiInputTextFlags_EnterReturnsTrue) == 0); // Not supported by InputScalar(). Please open an issue if you this would be useful to you. Otherwise use IsItemDeactivatedAfterEdit()!

void* p_data_default = (g.NextItemData.HasFlags & ImGuiNextItemDataFlags_HasRefVal) ? &g.NextItemData.RefVal : &g.DataTypeZeroValue;

if ((flags & ImGuiInputTextFlags_DisplayEmptyRefVal) && DataTypeCompare(data_type, p_data, p_data_default) == 0)

buf[0] = 0;

else

DataTypeFormatString(buf, IM_ARRAYSIZE(buf), data_type, p_data, format);

// Disable the MarkItemEdited() call in InputText but keep ImGuiItemStatusFlags_Edited.

// We call MarkItemEdited() ourselves by comparing the actual data rather than the string.

g.NextItemData.ItemFlags |= ImGuiItemFlags_NoMarkEdited;

flags |= ImGuiInputTextFlags_AutoSelectAll | (ImGuiInputTextFlags)ImGuiInputTextFlags_LocalizeDecimalPoint;

value_changed = DataTypeApplyFromText(buf, data_type, p_data, format, (flags & ImGuiInputTextFlags_ParseEmptyRefVal) ? p_data_default : NULL);

value_changed = DataTypeApplyFromText(buf, data_type, p_data, format, (flags & ImGuiInputTextFlags_ParseEmptyRefVal) ? p_data_default : NULL);

PushItemFlag(ImGuiItemFlags_ButtonRepeat, true);

if (ButtonEx("-", ImVec2(button_size, button_size)))

if (ButtonEx("+", ImVec2(button_size, button_size)))

PopItemFlag();

g.LastItemData.ItemFlags &= ~ImGuiItemFlags_NoMarkEdited;

// - imstb_textedit.h include

namespace ImStb

{

#include "imstb_textedit.h"

}

// This is only used in the path where the multiline widget is inactivate.

while (true)

{

const char* s_eol = strchr(s, '\n');

if (s_eol == NULL)

{

s = s + strlen(s);

break;

}

s = s_eol + 1;

}

// FIXME: Ideally we'd share code with ImFont::CalcTextSizeA()

static ImVec2 InputTextCalcTextSize(ImGuiContext* ctx, const char* text_begin, const char* text_end, const char** remaining, ImVec2* out_offset, bool stop_on_new_line)

const char* s = text_begin;

unsigned int c = (unsigned int)*s;

if (c < 0x80)

s += 1;

else

s += ImTextCharFromUtf8(&c, s, text_end);

const float char_width = ((int)c < font->IndexAdvanceX.Size ? font->IndexAdvanceX.Data[c] : font->FallbackAdvanceX) * scale;

// With our UTF-8 use of stb_textedit:

// - STB_TEXTEDIT_GETCHAR is nothing more than a a "GETBYTE". It's only used to compare to ascii or to copy blocks of text so we are fine.

// - One exception is the STB_TEXTEDIT_IS_SPACE feature which would expect a full char in order to handle full-width space such as 0x3000 (see ImCharIsBlankW).

// - ...but we don't use that feature.

static int STB_TEXTEDIT_STRINGLEN(const ImGuiInputTextState* obj) { return obj->TextLen; }

static char STB_TEXTEDIT_GETCHAR(const ImGuiInputTextState* obj, int idx) { IM_ASSERT(idx <= obj->TextLen); return obj->TextA[idx]; }

static float STB_TEXTEDIT_GETWIDTH(ImGuiInputTextState* obj, int line_start_idx, int char_idx) { unsigned int c; ImTextCharFromUtf8(&c, obj->TextA.Data + line_start_idx + char_idx, obj->TextA.Data + obj->TextLen); if ((ImWchar)c == '\n') return IMSTB_TEXTEDIT_GETWIDTH_NEWLINE; ImGuiContext& g = *obj->Ctx; return g.Font->GetCharAdvance((ImWchar)c) * g.FontScale; }

static char STB_TEXTEDIT_NEWLINE = '\n';

const char* text = obj->TextA.Data;

const char* text_remaining = NULL;

const ImVec2 size = InputTextCalcTextSize(obj->Ctx, text + line_start_idx, text + obj->TextLen, &text_remaining, NULL, true);

#define IMSTB_TEXTEDIT_GETNEXTCHARINDEX IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL

#define IMSTB_TEXTEDIT_GETPREVCHARINDEX IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL

static int IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL(ImGuiInputTextState* obj, int idx)

{

if (idx >= obj->TextLen)

return obj->TextLen + 1;

unsigned int c;

return idx + ImTextCharFromUtf8(&c, obj->TextA.Data + idx, obj->TextA.Data + obj->TextLen);

}

static int IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL(ImGuiInputTextState* obj, int idx)

{

if (idx <= 0)

return -1;

const char* p = ImTextFindPreviousUtf8Codepoint(obj->TextA.Data, obj->TextA.Data + idx);

return (int)(p - obj->TextA.Data);

}

static bool ImCharIsSeparatorW(unsigned int c)

static const unsigned int separator_list[] =

{

',', 0x3001, '.', 0x3002, ';', 0xFF1B, '(', 0xFF08, ')', 0xFF09, '{', 0xFF5B, '}', 0xFF5D,

'[', 0x300C, ']', 0x300D, '|', 0xFF5C, '!', 0xFF01, '\\', 0xFFE5, '/', 0x30FB, 0xFF0F,

'\n', '\r',

};

for (unsigned int separator : separator_list)

if (c == separator)

return true;

return false;

const char* curr_p = obj->TextA.Data + idx;

const char* prev_p = ImTextFindPreviousUtf8Codepoint(obj->TextA.Data, curr_p);

unsigned int curr_c; ImTextCharFromUtf8(&curr_c, curr_p, obj->TextA.Data + obj->TextLen);

unsigned int prev_c; ImTextCharFromUtf8(&prev_c, prev_p, obj->TextA.Data + obj->TextLen);

bool prev_white = ImCharIsBlankW(prev_c);

bool prev_separ = ImCharIsSeparatorW(prev_c);

bool curr_white = ImCharIsBlankW(curr_c);

bool curr_separ = ImCharIsSeparatorW(curr_c);

const char* curr_p = obj->TextA.Data + idx;

const char* prev_p = ImTextFindPreviousUtf8Codepoint(obj->TextA.Data, curr_p);

unsigned int prev_c; ImTextCharFromUtf8(&prev_c, curr_p, obj->TextA.Data + obj->TextLen);

unsigned int curr_c; ImTextCharFromUtf8(&curr_c, prev_p, obj->TextA.Data + obj->TextLen);

bool prev_white = ImCharIsBlankW(prev_c);

bool prev_separ = ImCharIsSeparatorW(prev_c);

bool curr_white = ImCharIsBlankW(curr_c);

bool curr_separ = ImCharIsSeparatorW(curr_c);

static int STB_TEXTEDIT_MOVEWORDLEFT_IMPL(ImGuiInputTextState* obj, int idx)

{

idx = IMSTB_TEXTEDIT_GETPREVCHARINDEX(obj, idx);

while (idx >= 0 && !is_word_boundary_from_right(obj, idx))

idx = IMSTB_TEXTEDIT_GETPREVCHARINDEX(obj, idx);

return idx < 0 ? 0 : idx;

}

static int STB_TEXTEDIT_MOVEWORDRIGHT_MAC(ImGuiInputTextState* obj, int idx)

{

int len = obj->TextLen;

idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);

while (idx < len && !is_word_boundary_from_left(obj, idx))

idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);

return idx > len ? len : idx;

}

static int STB_TEXTEDIT_MOVEWORDRIGHT_WIN(ImGuiInputTextState* obj, int idx)

{

idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);

int len = obj->TextLen;

while (idx < len && !is_word_boundary_from_right(obj, idx))

idx = IMSTB_TEXTEDIT_GETNEXTCHARINDEX(obj, idx);

return idx > len ? len : idx;

}

#define STB_TEXTEDIT_MOVEWORDLEFT STB_TEXTEDIT_MOVEWORDLEFT_IMPL // They need to be #define for stb_textedit.h

#define STB_TEXTEDIT_MOVEWORDRIGHT STB_TEXTEDIT_MOVEWORDRIGHT_IMPL

char* dst = obj->TextA.Data + pos;

obj->TextLen -= n;

const char* src = obj->TextA.Data + pos + n;

while (char c = *src++)

static bool STB_TEXTEDIT_INSERTCHARS(ImGuiInputTextState* obj, int pos, const char* new_text, int new_text_len)

const int text_len = obj->TextLen;

if (!is_resizable && (new_text_len + obj->TextLen + 1 > obj->BufCapacity))

if (new_text_len + text_len + 1 > obj->TextA.Size)

obj->TextA.resize(text_len + ImClamp(new_text_len, 32, ImMax(256, new_text_len)) + 1);

char* text = obj->TextA.Data;

memmove(text + pos + new_text_len, text + pos, (size_t)(text_len - pos));

memcpy(text + pos, new_text, (size_t)new_text_len);

obj->TextLen += new_text_len;

obj->TextA[obj->TextLen] = '\0';

stb_text_makeundo_replace(str, state, 0, str->TextLen, text_len);

ImStb::STB_TEXTEDIT_DELETECHARS(str, 0, str->TextLen);

// We added an extra indirection where 'Stb' is heap-allocated, in order facilitate the work of bindings generators.

ImGuiInputTextState::ImGuiInputTextState()

{

memset(this, 0, sizeof(*this));

Stb = IM_NEW(ImStbTexteditState);

memset(Stb, 0, sizeof(*Stb));

}

ImGuiInputTextState::~ImGuiInputTextState()

{

IM_DELETE(Stb);

}

stb_textedit_key(this, Stb, key);

CursorFollow = true;

CursorAnimReset();

}

void ImGuiInputTextState::OnCharPressed(unsigned int c)

{

// Convert the key to a UTF8 byte sequence.