pwmgr

// dear imgui, v1.91.5

// [SECTION] Widgets support: flags, enums, data structures

// [SECTION] Box-select support

// [SECTION] Error handling, State recovery support

#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast

#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning: zero as null pointer constant

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

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

#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 GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind

#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 "-Wdeprecated-enum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated

struct ImGuiBoxSelectState; // Box-selection state (currently used by multi-selection, could potentially be used by others)

struct ImGuiDataVarInfo; // Variable information (e.g. to access style variables from an enum)

struct ImGuiErrorRecoveryState; // Storage of stack sizes for error handling and recovery

struct ImGuiMultiSelectState; // Multi-selection persistent state (for focused selection).

struct ImGuiMultiSelectTempData; // Multi-selection temporary state (while traversing).

struct ImGuiNavItemData; // Result of a keyboard/gamepad directional navigation move query result

struct ImGuiTableHeaderData; // Storage for TableAngledHeadersRow()

struct ImGuiTreeNodeStackData; // Temporary storage for TreeNode().

typedef int ImGuiFocusRequestFlags; // -> enum ImGuiFocusRequestFlags_ // Flags: for FocusWindow()

typedef int ImGuiLogFlags; // -> enum ImGuiLogFlags_ // Flags: for LogBegin() text capturing function

typedef int ImGuiNavRenderCursorFlags; // -> enum ImGuiNavRenderCursorFlags_//Flags: for RenderNavCursor()

typedef int ImGuiWindowRefreshFlags; // -> enum ImGuiWindowRefreshFlags_ // Flags: for SetNextWindowRefreshPolicy()

#define IMGUI_DEBUG_LOG_ERROR(...) do { ImGuiContext& g2 = *GImGui; if (g2.DebugLogFlags & ImGuiDebugLogFlags_EventError) IMGUI_DEBUG_LOG(__VA_ARGS__); else g2.DebugLogSkippedErrors++; } while (0)

// Hint for branch prediction

#if (defined(__cplusplus) && (__cplusplus >= 202002L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L))

#define IM_LIKELY [[likely]]

#define IM_UNLIKELY [[unlikely]]

#else

#define IM_LIKELY

#define IM_UNLIKELY

#endif

// - Helper: ImGuiStorage

IMGUI_API const char* ImStrbol(const char* buf_mid_line, const char* buf_begin); // Find beginning-of-line

static inline bool ImCharIsXdigitA(char c) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); }

IMGUI_API int ImTextCountLines(const char* in_text, const char* in_text_end); // return number of lines taken by text. trailing carriage return doesn't count as an extra line.

static inline ImVec2 ImClamp(const ImVec2& v, const ImVec2&mn, const ImVec2&mx) { return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }

static inline float ImLinearRemapClamp(float s0, float s1, float d0, float d1, float x) { return ImSaturate((x - s0) / (s1 - s0)) * (d1 - d0) + d0; }

inline float ImTriangleArea(const ImVec2& a, const ImVec2& b, const ImVec2& c) { return ImFabs((a.x * (b.y - c.y)) + (b.x * (c.y - a.y)) + (c.x * (a.y - b.y))) * 0.5f; }

inline bool ImTriangleIsClockwise(const ImVec2& a, const ImVec2& b, const ImVec2& c) { return ((b.x - a.x) * (c.y - b.y)) - ((c.x - b.x) * (b.y - a.y)) > 0.0f; }

// Helper: ImGuiTextIndex

// Helper: ImGuiStorage

IMGUI_API ImGuiStoragePair* ImLowerBound(ImGuiStoragePair* in_begin, ImGuiStoragePair* in_end, ImGuiID key);

float FontScale; // Current/default font scale (== FontSize / Font->FontSize)

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

// [SECTION] Data types support

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

struct ImGuiDataVarInfo

{

ImGuiDataType Type;

ImU32 Count; // 1+

ImU32 Offset; // Offset in parent structure

void* GetVarPtr(void* parent) const { return (void*)((unsigned char*)parent + Offset); }

};

struct ImGuiDataTypeStorage

{

ImU8 Data[8]; // Opaque storage to fit any data up to ImGuiDataType_COUNT

};

// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo().

struct ImGuiDataTypeInfo

{

size_t Size; // Size in bytes

const char* Name; // Short descriptive name for the type, for debugging

const char* PrintFmt; // Default printf format for the type

const char* ScanFmt; // Default scanf format for the type

};

// Extend ImGuiDataType_

enum ImGuiDataTypePrivate_

{

ImGuiDataType_String = ImGuiDataType_COUNT + 1,

ImGuiDataType_Pointer,

ImGuiDataType_ID,

};

// Extend ImGuiItemFlags

// - input: PushItemFlag() manipulates g.CurrentItemFlags, g.NextItemData.ItemFlags, ItemAdd() calls may add extra flags too.

// - output: stored in g.LastItemData.ItemFlags

enum ImGuiItemFlagsPrivate_

ImGuiItemFlags_Disabled = 1 << 10, // false // Disable interactions (DOES NOT affect visuals. DO NOT mix direct use of this with BeginDisabled(). See BeginDisabled()/EndDisabled() for full disable feature, and github #211).

ImGuiItemFlags_ReadOnly = 1 << 11, // false // [ALPHA] Allow hovering interactions but underlying value is not changed.

ImGuiItemFlags_MixedValue = 1 << 12, // false // [BETA] Represent a mixed/indeterminate value, generally multi-selection where values differ. Currently only supported by Checkbox() (later should support all sorts of widgets)

ImGuiItemFlags_NoWindowHoverableCheck = 1 << 13, // false // Disable hoverable check in ItemHoverable()

ImGuiItemFlags_AllowOverlap = 1 << 14, // false // Allow being overlapped by another widget. Not-hovered to Hovered transition deferred by a frame.

ImGuiItemFlags_NoNavDisableMouseHover = 1 << 15, // false // Nav keyboard/gamepad mode doesn't disable hover highlight (behave as if NavHighlightItemUnderNav==false).

ImGuiItemFlags_NoMarkEdited = 1 << 16, // false // Skip calling MarkItemEdited()

ImGuiItemFlags_Inputable = 1 << 20, // false // [WIP] Auto-activate input mode when tab focused. Currently only used and supported by a few items before it becomes a generic feature.

ImGuiItemFlags_HasSelectionUserData = 1 << 21, // false // Set by SetNextItemSelectionUserData()

ImGuiItemFlags_IsMultiSelect = 1 << 22, // false // Set by SetNextItemSelectionUserData()

ImGuiItemFlags_Default_ = ImGuiItemFlags_AutoClosePopups, // Please don't change, use PushItemFlag() instead.

// Obsolete

//ImGuiItemFlags_SelectableDontClosePopup = !ImGuiItemFlags_AutoClosePopups, // Can't have a redirect as we inverted the behavior

ImGuiItemStatusFlags_HasClipRect = 1 << 9, // g.LastItemData.ClipRect is valid.

ImGuiItemStatusFlags_HasShortcut = 1 << 10, // g.LastItemData.Shortcut valid. Set by SetNextItemShortcut() -> ItemAdd().

ImGuiInputTextFlags_MergedItem = 1 << 27, // For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match.

ImGuiInputTextFlags_LocalizeDecimalPoint= 1 << 28, // For internal use by InputScalar() and TempInputScalar()

//ImGuiButtonFlags_Repeat = 1 << 10, // hold to repeat

//ImGuiButtonFlags_DontClosePopups = 1 << 13, // disable automatically closing parent popup on press

ImGuiButtonFlags_NoKeyModsAllowed = 1 << 16, // disable mouse interaction if a key modifier is held

ImGuiButtonFlags_NoNavFocus = 1 << 18, // don't override navigation focus when activated (FIXME: this is essentially used every time an item uses ImGuiItemFlags_NoNav, but because legacy specs don't requires LastItemData to be set ButtonBehavior(), we can't poll g.LastItemData.ItemFlags)

ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1 << 28,// FIXME-WIP: Hard-coded for CollapsingHeader()

ImGuiTreeNodeFlags_UpsideDownArrow = 1 << 29,// FIXME-WIP: Turn Down arrow into an Up arrow, for reversed trees (#6517)

ImGuiTreeNodeFlags_OpenOnMask_ = ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_OpenOnArrow,

// Flags for LogBegin() text capturing function

enum ImGuiLogFlags_

ImGuiLogFlags_None = 0,

ImGuiLogFlags_OutputTTY = 1 << 0,

ImGuiLogFlags_OutputFile = 1 << 1,

ImGuiLogFlags_OutputBuffer = 1 << 2,

ImGuiLogFlags_OutputClipboard = 1 << 3,

ImGuiLogFlags_OutputMask_ = ImGuiLogFlags_OutputTTY | ImGuiLogFlags_OutputFile | ImGuiLogFlags_OutputBuffer | ImGuiLogFlags_OutputClipboard,

// Forward declare imstb_textedit.h structure + make its main configuration define accessible

#undef IMSTB_TEXTEDIT_STRING

#undef IMSTB_TEXTEDIT_CHARTYPE

#define IMSTB_TEXTEDIT_STRING ImGuiInputTextState

#define IMSTB_TEXTEDIT_CHARTYPE char

#define IMSTB_TEXTEDIT_GETWIDTH_NEWLINE (-1.0f)

#define IMSTB_TEXTEDIT_UNDOSTATECOUNT 99

#define IMSTB_TEXTEDIT_UNDOCHARCOUNT 999

namespace ImStb { struct STB_TexteditState; }

typedef ImStb::STB_TexteditState ImStbTexteditState;

ImStbTexteditState* Stb; // State for stb_textedit.h

int TextLen; // UTF-8 length of the string in TextA (in bytes)

ImVector<char> TextA; // main UTF8 buffer. TextA.Size is a buffer size! Should always be >= buf_size passed by user (and of course >= CurLenA + 1).

ImVector<char> TextToRevertTo; // value to revert to when pressing Escape = backup of end-user buffer at the time of focus (in UTF-8, unaltered)

ImVector<char> CallbackTextBackup; // temporary storage for callback to support automatic reconcile of undo-stack

int BufCapacity; // end-user buffer capacity (include zero terminator)

ImVec2 Scroll; // horizontal offset (managed manually) + vertical scrolling (pulled from child window's own Scroll.y)

ImGuiInputTextState();

~ImGuiInputTextState();

void ClearText() { TextLen = 0; TextA[0] = 0; CursorClamp(); }

void ClearFreeMemory() { TextA.clear(); TextToRevertTo.clear(); }

void OnCharPressed(unsigned int c);

void CursorAnimReset();

void CursorClamp();

bool HasSelection() const;

void ClearSelection();

int GetCursorPos() const;

int GetSelectionStart() const;

int GetSelectionEnd() const;

void SelectAll();

void ReloadUserBufAndSelectAll();

void ReloadUserBufAndKeepSelection();

void ReloadUserBufAndMoveToEnd();

};

enum ImGuiWindowRefreshFlags_

{

ImGuiWindowRefreshFlags_None = 0,

ImGuiWindowRefreshFlags_TryToAvoidRefresh = 1 << 0, // [EXPERIMENTAL] Try to keep existing contents, USER MUST NOT HONOR BEGIN() RETURNING FALSE AND NOT APPEND.

ImGuiWindowRefreshFlags_RefreshOnHover = 1 << 1, // [EXPERIMENTAL] Always refresh on hover

ImGuiWindowRefreshFlags_RefreshOnFocus = 1 << 2, // [EXPERIMENTAL] Always refresh on focus

// Refresh policy/frequency, Load Balancing etc.

ImGuiNextWindowDataFlags_HasRefreshPolicy = 1 << 9,

ImGuiWindowRefreshFlags RefreshFlagsVal;

ImGuiNextItemDataFlags_HasRefVal = 1 << 3,

ImGuiNextItemDataFlags_HasStorageID = 1 << 4,

ImGuiNextItemDataFlags HasFlags; // Called HasFlags instead of Flags to avoid mistaking this

ImGuiItemFlags ItemFlags; // Currently only tested/used for ImGuiItemFlags_AllowOverlap and ImGuiItemFlags_HasSelectionUserData.

ImGuiID FocusScopeId; // Set by SetNextItemSelectionUserData()

ImGuiInputFlags ShortcutFlags; // Set by SetNextItemShortcut()

ImU8 OpenCond; // Set by SetNextItemOpen()

ImGuiDataTypeStorage RefVal; // Not exposed yet, for ImGuiInputTextFlags_ParseEmptyAsRefVal

ImGuiID StorageId; // Set by SetNextItemStorageID()

inline void ClearFlags() { HasFlags = ImGuiNextItemDataFlags_None; ItemFlags = ImGuiItemFlags_None; } // Also cleared manually by ItemAdd()!

ImGuiItemFlags ItemFlags; // See ImGuiItemFlags_

// Rarely used fields are not explicitly cleared, only valid when the corresponding ImGuiItemStatusFlags ar set.

ImRect DisplayRect; // Display rectangle. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasDisplayRect) is set.

ImRect ClipRect; // Clip rectangle at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasClipRect) is set..

ImGuiKeyChord Shortcut; // Shortcut at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasShortcut) is set..

// Store data emitted by TreeNode() for usage by TreePop()

// - To implement ImGuiTreeNodeFlags_NavLeftJumpsBackHere: store the minimum amount of data

// which we can't infer in TreePop(), to perform the equivalent of NavApplyItemToResult().

// Only stored when the node is a potential candidate for landing on a Left arrow jump.

struct ImGuiTreeNodeStackData

ImGuiTreeNodeFlags TreeFlags;

ImGuiItemFlags ItemFlags; // Used for nav landing

ImRect NavRect; // Used for nav landing

// sizeof() = 20

struct IMGUI_API ImGuiErrorRecoveryState

short SizeOfWindowStack;

short SizeOfTreeStack;

ImGuiErrorRecoveryState() { memset(this, 0, sizeof(*this)); }

ImGuiWindow* Window;

ImGuiLastItemData ParentLastItemDataBackup;

ImGuiErrorRecoveryState StackSizesInBegin; // Store size of various stacks for asserting

bool DisabledOverrideReenable; // Non-child window override disabled flag

ImGuiWindow* RestoreNavWindow;// Set on OpenPopup(), a NavWindow that will be restored on popup close

#define ImGuiKey_NavGamepadActivate (g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceRight : ImGuiKey_GamepadFaceDown)

#define ImGuiKey_NavGamepadCancel (g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceDown : ImGuiKey_GamepadFaceRight)

#define ImGuiKeyOwner_NoOwner ((ImGuiID)-1) // Require key to have no owner.

//#define ImGuiKeyOwner_None ImGuiKeyOwner_NoOwner // We previously called this 'ImGuiKeyOwner_None' but it was inconsistent with our pattern that _None values == 0 and quite dangerous. Also using _NoOwner makes the IsKeyPressed() calls more explicit.

ImU16 Mods; // Technically we'd only need 4-bits but for simplify we store ImGuiMod_ values which need 16-bits.

ImGuiKeyRoutingData() { NextEntryIndex = -1; Mods = 0; RoutingCurrScore = RoutingNextScore = 255; RoutingCurr = RoutingNext = ImGuiKeyOwner_NoOwner; }

ImGuiKeyOwnerData() { OwnerCurr = OwnerNext = ImGuiKeyOwner_NoOwner; LockThisFrame = LockUntilRelease = false; }

// Extend ImGuiInputFlags_

enum ImGuiInputFlagsPrivate_

// - Repeat mode: Repeat rate selection

ImGuiInputFlags_RepeatRateDefault = 1 << 1, // Repeat rate: Regular (default)

ImGuiInputFlags_RepeatRateNavMove = 1 << 2, // Repeat rate: Fast

ImGuiInputFlags_RepeatRateNavTweak = 1 << 3, // Repeat rate: Faster

// - Repeat mode: Specify when repeating key pressed can be interrupted.

// - In theory ImGuiInputFlags_RepeatUntilOtherKeyPress may be a desirable default, but it would break too many behavior so everything is opt-in.

ImGuiInputFlags_RepeatUntilRelease = 1 << 4, // Stop repeating when released (default for all functions except Shortcut). This only exists to allow overriding Shortcut() default behavior.

ImGuiInputFlags_RepeatUntilKeyModsChange = 1 << 5, // Stop repeating when released OR if keyboard mods are changed (default for Shortcut)

ImGuiInputFlags_RepeatUntilOtherKeyPress = 1 << 7, // Stop repeating when released OR if any other keyboard key is pressed during the repeat

// - Locking key away from non-input aware code. Locking is useful to make input-owner-aware code steal keys from non-input-owner-aware code. If all code is input-owner-aware locking would never be necessary.

ImGuiInputFlags_LockThisFrame = 1 << 20, // Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared at end of frame.

ImGuiInputFlags_LockUntilRelease = 1 << 21, // Further accesses to key data will require EXPLICIT owner ID (ImGuiKeyOwner_Any/0 will NOT accepted for polling). Cleared when the key is released or at end of each frame if key is released.

// - Condition for SetItemKeyOwner()

ImGuiInputFlags_CondHovered = 1 << 22, // Only set if item is hovered (default to both)

ImGuiInputFlags_CondActive = 1 << 23, // Only set if item is active (default to both)

ImGuiInputFlags_CondDefault_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive,

ImGuiInputFlags_RouteTypeMask_ = ImGuiInputFlags_RouteActive | ImGuiInputFlags_RouteFocused | ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteAlways,

ImGuiInputFlags_RouteOptionsMask_ = ImGuiInputFlags_RouteOverFocused | ImGuiInputFlags_RouteOverActive | ImGuiInputFlags_RouteUnlessBgFocused | ImGuiInputFlags_RouteFromRootWindow,

ImGuiInputFlags_SupportedByShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_,

ImGuiInputFlags_SupportedBySetNextItemShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_ | ImGuiInputFlags_Tooltip,

enum ImGuiNavRenderCursorFlags_

ImGuiNavRenderCursorFlags_None = 0,

ImGuiNavRenderCursorFlags_Compact = 1 << 1, // Compact highlight, no padding/distance from focused item

ImGuiNavRenderCursorFlags_AlwaysDraw = 1 << 2, // Draw rectangular highlight if (g.NavId == id) even when g.NavCursorVisible == false, aka even when using the mouse.

ImGuiNavRenderCursorFlags_NoRounding = 1 << 3,

#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS

ImGuiNavHighlightFlags_None = ImGuiNavRenderCursorFlags_None, // Renamed in 1.91.4

ImGuiNavHighlightFlags_Compact = ImGuiNavRenderCursorFlags_Compact, // Renamed in 1.91.4

ImGuiNavHighlightFlags_AlwaysDraw = ImGuiNavRenderCursorFlags_AlwaysDraw, // Renamed in 1.91.4

ImGuiNavHighlightFlags_NoRounding = ImGuiNavRenderCursorFlags_NoRounding, // Renamed in 1.91.4

#endif

ImGuiNavMoveFlags_NoSetNavCursorVisible = 1 << 14, // Do not alter the nav cursor visible state

ImGuiNavMoveFlags_NoClearActiveId = 1 << 15, // (Experimental) Do not clear active id when applying move result

// Storage for navigation query/results

ImGuiItemFlags ItemFlags; // ????,Move // Best candidate item flags

ImGuiSelectionUserData SelectionUserData;//I+Mov // Best candidate SetNextItemSelectionUserData() value. Valid if (ItemFlags & ImGuiItemFlags_HasSelectionUserData)

void Clear() { Window = NULL; ID = FocusScopeId = 0; ItemFlags = 0; SelectionUserData = -1; DistBox = DistCenter = DistAxial = FLT_MAX; }

// Storage for PushFocusScope(), g.FocusScopeStack[], g.NavFocusRoute[]

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

// [SECTION] Box-select support

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

struct ImGuiBoxSelectState

{

// Active box-selection data (persistent, 1 active at a time)

ImGuiID ID;

bool IsActive;

bool IsStarting;

bool IsStartedFromVoid; // Starting click was not from an item.

bool IsStartedSetNavIdOnce;

bool RequestClear;

ImGuiKeyChord KeyMods : 16; // Latched key-mods for box-select logic.

ImVec2 StartPosRel; // Start position in window-contents relative space (to support scrolling)

ImVec2 EndPosRel; // End position in window-contents relative space

ImVec2 ScrollAccum; // Scrolling accumulator (to behave at high-frame spaces)

ImGuiWindow* Window;

// Temporary/Transient data

bool UnclipMode; // (Temp/Transient, here in hot area). Set/cleared by the BeginMultiSelect()/EndMultiSelect() owning active box-select.

ImRect UnclipRect; // Rectangle where ItemAdd() clipping may be temporarily disabled. Need support by multi-select supporting widgets.

ImRect BoxSelectRectPrev; // Selection rectangle in absolute coordinates (derived every frame from BoxSelectStartPosRel and MousePos)

ImRect BoxSelectRectCurr;

ImGuiBoxSelectState() { memset(this, 0, sizeof(*this)); }

};

// Temporary storage for multi-select

struct IMGUI_API ImGuiMultiSelectTempData

{

ImGuiMultiSelectIO IO; // MUST BE FIRST FIELD. Requests are set and returned by BeginMultiSelect()/EndMultiSelect() + written to by user during the loop.

ImGuiMultiSelectState* Storage;

ImGuiID FocusScopeId; // Copied from g.CurrentFocusScopeId (unless another selection scope was pushed manually)

ImGuiMultiSelectFlags Flags;

ImVec2 ScopeRectMin;

ImVec2 BackupCursorMaxPos;

ImGuiSelectionUserData LastSubmittedItem; // Copy of last submitted item data, used to merge output ranges.

ImGuiID BoxSelectId;

ImGuiKeyChord KeyMods;

ImS8 LoopRequestSetAll; // -1: no operation, 0: clear all, 1: select all.

bool IsEndIO; // Set when switching IO from BeginMultiSelect() to EndMultiSelect() state.

bool IsFocused; // Set if currently focusing the selection scope (any item of the selection). May be used if you have custom shortcut associated to selection.

bool IsKeyboardSetRange; // Set by BeginMultiSelect() when using Shift+Navigation. Because scrolling may be affected we can't afford a frame of lag with Shift+Navigation.

bool NavIdPassedBy;

bool RangeSrcPassedBy; // Set by the item that matches RangeSrcItem.

bool RangeDstPassedBy; // Set by the item that matches NavJustMovedToId when IsSetRange is set.

ImGuiMultiSelectTempData() { Clear(); }

void Clear() { size_t io_sz = sizeof(IO); ClearIO(); memset((void*)(&IO + 1), 0, sizeof(*this) - io_sz); } // Zero-clear except IO as we preserve IO.Requests[] buffer allocation.

void ClearIO() { IO.Requests.resize(0); IO.RangeSrcItem = IO.NavIdItem = ImGuiSelectionUserData_Invalid; IO.NavIdSelected = IO.RangeSrcReset = false; }

};

// Persistent storage for multi-select (as long as selection is alive)

struct IMGUI_API ImGuiMultiSelectState

{

ImGuiWindow* Window;

ImGuiID ID;

int LastFrameActive; // Last used frame-count, for GC.

int LastSelectionSize; // Set by BeginMultiSelect() based on optional info provided by user. May be -1 if unknown.

ImS8 RangeSelected; // -1 (don't have) or true/false

ImS8 NavIdSelected; // -1 (don't have) or true/false

ImGuiSelectionUserData RangeSrcItem; //

ImGuiSelectionUserData NavIdItem; // SetNextItemSelectionUserData() value for NavId (if part of submitted items)

ImGuiMultiSelectState() { Window = NULL; ID = 0; LastFrameActive = LastSelectionSize = 0; RangeSelected = NavIdSelected = -1; RangeSrcItem = NavIdItem = ImGuiSelectionUserData_Invalid; }

};

// Per-viewport work area

// - Insets are >= 0.0f values, distance from viewport corners to work area.

// - BeginMainMenuBar() and DockspaceOverViewport() tend to use work area to avoid stepping over existing contents.

// - Generally 'safeAreaInsets' in iOS land, 'DisplayCutout' in Android land.

ImVec2 WorkInsetMin; // Work Area inset locked for the frame. GetWorkRect() always fits within GetMainRect().

ImVec2 WorkInsetMax; // "

ImVec2 BuildWorkInsetMin; // Work Area inset accumulator for current frame, to become next frame's WorkInset

ImVec2 BuildWorkInsetMax; // "

ImVec2 CalcWorkRectPos(const ImVec2& inset_min) const { return ImVec2(Pos.x + inset_min.x, Pos.y + inset_min.y); }

ImVec2 CalcWorkRectSize(const ImVec2& inset_min, const ImVec2& inset_max) const { return ImVec2(ImMax(0.0f, Size.x - inset_min.x - inset_max.x), ImMax(0.0f, Size.y - inset_min.y - inset_max.y)); }

void UpdateWorkRect() { WorkPos = CalcWorkRectPos(WorkInsetMin); WorkSize = CalcWorkRectSize(WorkInsetMin, WorkInsetMax); } // Update public fields

ImRect GetBuildWorkRect() const { ImVec2 pos = CalcWorkRectPos(BuildWorkInsetMin); ImVec2 size = CalcWorkRectSize(BuildWorkInsetMin, BuildWorkInsetMax); return ImRect(pos.x, pos.y, pos.x + size.x, pos.y + size.y); }

ImGuiLocKey_OpenLink_s,

ImGuiLocKey_CopyLink,

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

// [SECTION] Error handling, State recovery support

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

// Macros used by Recoverable Error handling

// - Only dispatch error if _EXPR: evaluate as assert (similar to an assert macro).

// - The message will always be a string literal, in order to increase likelihood of being display by an assert handler.

// - See 'Demo->Configuration->Error Handling' and ImGuiIO definitions for details on error handling.

// - Read https://github.com/ocornut/imgui/wiki/Error-Handling for details on error handling.

#ifndef IM_ASSERT_USER_ERROR

#define IM_ASSERT_USER_ERROR(_EXPR,_MSG) do { if (!(_EXPR) && ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } } while (0) // Recoverable User Error

#endif

// The error callback is currently not public, as it is expected that only advanced users will rely on it.

typedef void (*ImGuiErrorCallback)(ImGuiContext* ctx, void* user_data, const char* msg); // Function signature for g.ErrorCallback

ImGuiDebugLogFlags_EventError = 1 << 0, // Error submitted by IM_ASSERT_USER_ERROR()

ImGuiDebugLogFlags_EventActiveId = 1 << 1,

ImGuiDebugLogFlags_EventFocus = 1 << 2,

ImGuiDebugLogFlags_EventPopup = 1 << 3,

ImGuiDebugLogFlags_EventNav = 1 << 4,

ImGuiDebugLogFlags_EventClipper = 1 << 5,

ImGuiDebugLogFlags_EventSelection = 1 << 6,

ImGuiDebugLogFlags_EventIO = 1 << 7,

ImGuiDebugLogFlags_EventInputRouting = 1 << 8,

ImGuiDebugLogFlags_EventDocking = 1 << 9, // Unused in this branch

ImGuiDebugLogFlags_EventViewport = 1 << 10, // Unused in this branch

ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport,

int HighlightMonitorIdx = -1;

ImGuiID HighlightViewportID = 0;

ImGuiPlatformIO PlatformIO;

float FontScale; // == FontSize / Font->FontSize

float CurrentDpiScale; // Current window/viewport DpiScale

char ContextName[16]; // Storage for a context name (to facilitate debugging multi-context setups)

ImVec2 WindowsHoverPadding; // Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, WINDOWS_HOVER_PADDING).

ImGuiWindow* HoveredWindowBeforeClear; // Window the mouse is hovering. Filled even with _NoMouse. This is currently useful for multi-context compositors.

ImGuiID DebugDrawIdConflicts; // Set when we detect multiple items with the same identifier

int HoveredIdPreviousFrameItemCount; // Count numbers of items using the same ID as last frame's hovered id

bool HoveredIdAllowOverlap;

bool HoveredIdIsDisabled; // At least one widget passed the rect test, but has been discarded by disabled flag or popup inhibit. May be true even if HoveredId == 0.

bool ItemUnclipByLog; // Disable ItemAdd() clipping, essentially a memory-locality friendly copy of LogEnabled

// Key/Input Ownership + Shortcut Routing system

// - Input query can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID.

bool ActiveIdUsingAllKeyboardKeys; // Active widget will want to read all keyboard keys inputs. (this is a shortcut for not taking ownership of 100+ keys, frequently used by drag operations)

//ImU32 ActiveIdUsingNavInputMask; // [OBSOLETE] Since (IMGUI_VERSION_NUM >= 18804) : 'g.ActiveIdUsingNavInputMask |= (1 << ImGuiNavInput_Cancel);' becomes --> 'SetKeyOwner(ImGuiKey_Escape, g.ActiveId) and/or SetKeyOwner(ImGuiKey_NavGamepadCancel, g.ActiveId);'

ImVector<ImGuiTreeNodeStackData>TreeNodeStack; // Stack for TreeNode()

// Keyboard/Gamepad Navigation

bool NavCursorVisible; // Nav focus cursor/rectangle is visible? We hide it after a mouse click. We show it after a nav move.

bool NavHighlightItemUnderNav; // Disable mouse hovering highlight. Highlight navigation focused item instead of mouse hovered item.

//bool NavDisableHighlight; // Old name for !g.NavCursorVisible before 1.91.4 (2024/10/18). OPPOSITE VALUE (g.NavDisableHighlight == !g.NavCursorVisible)

//bool NavDisableMouseHover; // Old name for g.NavHighlightItemUnderNav before 1.91.1 (2024/10/18) this was called When user starts using keyboard/gamepad, we hide mouse hovering highlight until mouse is touched again.

bool NavMousePosDirty; // When set we will update mouse position if io.ConfigNavMoveSetMousePos is set (not enabled by default)

bool NavIdIsAlive; // Nav widget has been seen this frame ~~ NavRectRel is valid

ImGuiWindow* NavWindow; // Focused window for navigation. Could be called 'FocusedWindow'

ImGuiNavLayer NavLayer; // Focused layer (main scrolling layer, or menu/title bar layer)

ImVector<ImGuiFocusScopeData> NavFocusRoute; // Reversed copy focus scope stack for NavId (should contains NavFocusScopeId). This essentially follow the window->ParentWindowForFocusRoute chain.

ImS8 NavCursorHideFrames;

// Navigation: record of last move request

ImGuiID NavJustMovedFromFocusScopeId; // Just navigated from this focus scope id (result of a successfully MoveRequest).

ImGuiID NavJustMovedToId; // Just navigated to this id (result of a successfully MoveRequest).

ImGuiID NavJustMovedToFocusScopeId; // Just navigated to this focus scope id (result of a successfully MoveRequest).

ImGuiKeyChord NavJustMovedToKeyMods;

bool NavJustMovedToIsTabbing; // Copy of ImGuiNavMoveFlags_IsTabbing. Maybe we should store whole flags.

bool NavJustMovedToHasSelectionData; // Copy of move result's ItemFlags & ImGuiItemFlags_HasSelectionUserData). Maybe we should just store ImGuiNavItemData.

ImGuiKeyChord ConfigNavWindowingKeyNext; // = ImGuiMod_Ctrl | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiKey_Tab on OS X). For reconfiguration (see #4828)

ImGuiKeyChord ConfigNavWindowingKeyPrev; // = ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiMod_Shift | ImGuiKey_Tab on OS X)

// Multi-Select state

ImGuiBoxSelectState BoxSelectState;

ImGuiMultiSelectTempData* CurrentMultiSelect;

int MultiSelectTempDataStacked; // Temporary multi-select data size (because we leave previous instances undestructed, we generally don't use MultiSelectTempData.Size)

ImVector<ImGuiMultiSelectTempData> MultiSelectTempData;

ImPool<ImGuiMultiSelectState> MultiSelectStorage;

ImGuiDataTypeStorage DataTypeZeroValue; // 0 for all data types

int BeginMenuDepth;

int BeginComboDepth;

short ScrollbarSeekMode; // 0: scroll to clicked location, -1/+1: prev/next page.

float ScrollbarClickDeltaToGrabCenter; // When scrolling to mouse location: distance between mouse and center of grab box, normalized in parent space.

ImGuiWindow* TooltipPreviousWindow; // Window of last tooltip submitted during the frame

ImGuiPlatformImeData PlatformImeDataPrev; // Previous frame data. When changed we call the platform_io.Platform_SetImeDataFn() handler.

ImGuiLogFlags LogFlags; // Capture flags/type

ImGuiWindow* LogWindow;

// Error Handling

ImGuiErrorCallback ErrorCallback; // = NULL. May be exposed in public API eventually.

void* ErrorCallbackUserData; // = NULL

ImVec2 ErrorTooltipLockedPos;

bool ErrorFirst;

int ErrorCountCurrentFrame; // [Internal] Number of errors submitted this frame.

ImGuiErrorRecoveryState StackSizesInNewFrame; // [Internal]

ImGuiErrorRecoveryState*StackSizesInBeginForCurrentWindow; // [Internal]

int DebugDrawIdConflictsCount; // Locked count (preserved when holding CTRL)

int DebugLogSkippedErrors;