pwmgr

// dear imgui, v1.91.5

#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

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

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

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

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

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

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

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

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

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

g.ActiveIdMouseButton = mouse_button_clicked;

else

g.ActiveIdMouseButton = mouse_button_clicked;

else

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;

if (g.NavHighlightActivatedId == id)

ImU32 cross_col = GetColorU32(ImGuiCol_Text);

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

const float border_size = window->WindowBorderSize;

IM_ASSERT(scrollbar_size > 0.0f);

return ImRect(inner_rect.Min.x, ImMax(outer_rect.Min.y, outer_rect.Max.y - border_size - scrollbar_size), inner_rect.Max.x - border_size, outer_rect.Max.y - border_size);

return ImRect(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y, outer_rect.Max.x - border_size, inner_rect.Max.y - border_size);

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)

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

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

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

window->DrawList->AddRectFilled(bb_frame.Min, bb_frame.Max, bg_col, window->WindowRounding, flags);

// - Read about ImTextureID here: https://github.com/ocornut/imgui/wiki/Image-Loading-and-Displaying-Examples

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

const float border_size = (border_col.w > 0.0f) ? 1.0f : 0.0f;

const ImVec2 padding(border_size, border_size);

if (border_size > 0.0f)

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

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

// ImageButton() is flawed as 'id' is always derived from 'texture_id' (see #2464 #1390)

// We provide this internal helper to write your own variant while we figure out how to redesign the public ImageButton() API.

bool ImGui::ImageButtonEx(ImGuiID id, ImTextureID texture_id, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& bg_col, const ImVec4& tint_col, ImGuiButtonFlags flags)

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

// Note that ImageButton() adds style.FramePadding*2.0f to provided size. This is in order to facilitate fitting an image in a button.

bool ImGui::ImageButton(const char* str_id, ImTextureID user_texture_id, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& bg_col, const ImVec4& tint_col)

return ImageButtonEx(window->GetID(str_id), user_texture_id, image_size, uv0, uv1, bg_col, tint_col);

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

ImVec2 pos = window->DC.CursorPos;

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.

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

if (TextLink(label))

if (g.PlatformIO.Platform_OpenInShellFn != NULL)

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

RenderTextEllipsis(window->DrawList, label_pos, ImVec2(bb.Max.x, bb.Max.y + style.ItemSpacing.y), bb.Max.x, bb.Max.x, label, label_end, &label_size);

void ImGui::ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess)

items[0].Width = ImMax(items[0].Width - width_excess, 1.0f);

ImQsort(items, (size_t)count, sizeof(ImGuiShrinkWidthItem), ShrinkWidthItemComparer);

while (width_excess > 0.0f && count_same_width < count)

float width_to_remove_per_item = ImMin(width_excess / count_same_width, max_width_to_remove_per_item);

items[item_n].Width -= width_to_remove_per_item;

width_excess -= width_to_remove_per_item * count_same_width;

ImGuiNextWindowDataFlags backup_next_window_data_flags = g.NextWindowData.Flags;

g.NextWindowData.Flags = backup_next_window_data_flags;

if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint)

if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.x <= 0.0f) // Don't apply constraints if user specified a size

if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSize) == 0 || g.NextWindowData.SizeVal.y <= 0.0f)

IM_ASSERT(0); // This should never happen as we tested for IsPopupOpen() above

p += strlen(p) + 1;

if (popup_max_height_in_items != -1 && !(g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint))

p += strlen(p) + 1;

if (g.IO.KeyAlt)

if (g.IO.KeyShift)

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

// Tabbing or CTRL-clicking on Drag turns it into an InputText

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

// Tabbing or CTRL-clicking on Slider turns it into an input box

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

*v_rad = v_deg * (2 * IM_PI) / 360.0f;

// Create text input in place of another active widget (e.g. used when doing a CTRL+Click on drag/slider widgets)

// This is intended: this way we allow CTRL+Click manual input to set a value out of bounds, for maximum flexibility.

// - InputTextGetCharInfo() [Internal]

// - InputTextReindexLines() [Internal]

// - InputTextReindexLinesRange() [Internal]

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

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

{

int line_count = 0;

const char* s = text_begin;

while (true)

{

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

line_count++;

if (s_eol == NULL)

{

s = s + strlen(s);

break;

}

s = s_eol + 1;

}

*out_text_end = s;

return line_count;

}

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

ImFont* font = g.Font;

const float line_height = g.FontSize;

const float scale = line_height / font->FontSize;

ImVec2 text_size = ImVec2(0, 0);

float line_width = 0.0f;

const char* s = text_begin;

while (s < text_end)

{

unsigned int c = (unsigned int)*s;

if (c < 0x80)

s += 1;

else

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

if (c == '\n')

{

text_size.x = ImMax(text_size.x, line_width);

text_size.y += line_height;

line_width = 0.0f;

if (stop_on_new_line)

break;

continue;

}

if (c == '\r')

continue;

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

line_width += char_width;

}

if (text_size.x < line_width)

text_size.x = line_width;

if (out_offset)

*out_offset = ImVec2(line_width, text_size.y + line_height); // offset allow for the possibility of sitting after a trailing \n

if (line_width > 0 || text_size.y == 0.0f) // whereas size.y will ignore the trailing \n

text_size.y += line_height;

if (remaining)

*remaining = s;

return text_size;

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

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

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

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

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

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

// When ImGuiInputTextFlags_Password is set, we don't want actions such as CTRL+Arrow to leak the fact that underlying data are blanks or separators.

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

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

// Offset remaining text (FIXME-OPT: Use memmove)

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

while (char c = *src++)

*dst++ = c;

*dst = '\0';

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

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

return false;

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

if (!is_resizable)

return false;

return true;

if (ImStb::STB_TEXTEDIT_INSERTCHARS(str, 0, text, text_len))

stb_textedit_text(this, Stb, utf8, (int)strlen(utf8));

void ImGuiInputTextState::ReloadUserBufAndSelectAll() { ReloadUserBuf = true; ReloadSelectionStart = 0; ReloadSelectionEnd = INT_MAX; }

void ImGuiInputTextState::ReloadUserBufAndKeepSelection() { ReloadUserBuf = true; ReloadSelectionStart = Stb->select_start; ReloadSelectionEnd = Stb->select_end; }

void ImGuiInputTextState::ReloadUserBufAndMoveToEnd() { ReloadUserBuf = true; ReloadSelectionStart = ReloadSelectionEnd = INT_MAX; }

// Public API to manipulate UTF-8 text

// We expose UTF-8 to the user (unlike the STB_TEXTEDIT_* functions which are manipulating wchar)

while (char c = *src++)

*dst++ = c;

*dst = '\0';

// Grow internal buffer if needed

const int new_text_len = new_text_end ? (int)(new_text_end - new_text) : (int)strlen(new_text);

if (new_text_len + BufTextLen >= BufSize)

{

if (!is_resizable)

return;

// Contrary to STB_TEXTEDIT_INSERTCHARS() this is working in the UTF8 buffer, hence the mildly similar code (until we remove the U16 buffer altogether!)

ImGuiContext& g = *Ctx;

ImGuiInputTextState* edit_state = &g.InputTextState;

IM_ASSERT(edit_state->ID != 0 && g.ActiveId == edit_state->ID);

IM_ASSERT(Buf == edit_state->TextA.Data);

edit_state->TextA.resize(new_buf_size + 1);

Buf = edit_state->TextA.Data;

BufSize = edit_state->BufCapacity = new_buf_size;

BufDirty = true;

BufTextLen += new_text_len;

pass |= (c == '\n') && (flags & ImGuiInputTextFlags_Multiline) != 0; // Note that an Enter KEY will emit \r and be ignored (we poll for KEY in InputText() code)

// Full-width -> half-width conversion for numeric fields (https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block)

// Find the shortest single replacement we can make to get the new text from the old text.

// Important: needs to be run before TextW is rewritten with the new characters because calling STB_TEXTEDIT_GETCHAR() at the end.

static void InputTextReconcileUndoStateAfterUserCallback(ImGuiInputTextState* state, const char* new_buf_a, int new_length_a)

const char* old_buf = state->CallbackTextBackup.Data;

const int old_length = state->CallbackTextBackup.Size - 1;

const int shorter_length = ImMin(old_length, new_length_a);

if (old_buf[first_diff] != new_buf_a[first_diff])

if (first_diff == old_length && first_diff == new_length_a)

int new_last_diff = new_length_a - 1;

if (old_buf[old_last_diff] != new_buf_a[new_last_diff])

// - If you want to use ImGui::InputText() with std::string, see misc/cpp/imgui_stdlib.h

// (FIXME: Rather confusing and messy function, among the worse part of our codebase, expecting to rewrite a V2 at some point.. Partly because we are

// doing UTF8 > U16 > UTF8 conversions on the go to easily interface with stb_textedit. Ideally should stay in UTF-8 all the time. See https://github.com/nothings/stb/issues/188)

// Prevent NavActivation from Tabbing when our widget accepts Tab inputs: this allows cycling through widgets without stopping.

if (g.NavActivateId == id && (g.NavActivateFlags & ImGuiActivateFlags_FromTabbing) && (flags & ImGuiInputTextFlags_AllowTabInput))

const bool init_reload_from_user_buf = (state != NULL && state->ReloadUserBuf);

if ((init_state && g.ActiveId != id) || init_changed_specs || init_reload_from_user_buf)

state->ReloadUserBuf = false;

const int buf_len = (int)strlen(buf);

if (!init_reload_from_user_buf)

{

// Take a copy of the initial buffer value.

state->TextToRevertTo.resize(buf_len + 1); // UTF-8. we use +1 to make sure that .Data is always pointing to at least an empty string.

memcpy(state->TextToRevertTo.Data, buf, buf_len + 1);

}

bool recycle_state = (state->ID == id && !init_changed_specs && !init_reload_from_user_buf);

if (recycle_state && (state->TextLen != buf_len || (strncmp(state->TextA.Data, buf, buf_len) != 0)))

state->TextA.resize(buf_size + 1); // we use +1 to make sure that .Data is always pointing to at least an empty string.

state->TextLen = (int)strlen(buf);

memcpy(state->TextA.Data, buf, state->TextLen + 1);

if (recycle_state)

// Recycle existing cursor/selection/undo stack but clamp position

// Note a single mouse click will override the cursor/position immediately by calling stb_textedit_click handler.

state->CursorClamp();

else

{

state->Scroll = ImVec2(0.0f, 0.0f);