{

int x, y;

constexpr ImVec2i() : x(0), y(0) {}

constexpr ImVec2i(int _x, int _y) : x(_x), y(_y) {}

{

short x, y;

constexpr ImVec2ih() : x(0), y(0) {}

constexpr ImVec2ih(short _x, short _y) : x(_x), y(_y) {}

constexpr explicit ImVec2ih(const ImVec2& rhs) : x((short)rhs.x), y((short)rhs.y) {}

{

n2--;

while (n <= n2)

{

int a_mod = (n & 31);

int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;

ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);

arr[n >> 5] |= mask;

n = (n + 32) & ~31;

}

{

ImU32 Storage[(BITCOUNT + 31) >> 5];

ImBitArray() { ClearAllBits(); }

void ClearAllBits() { memset(Storage, 0, sizeof(Storage)); }

void SetAllBits() { memset(Storage, 255, sizeof(Storage)); }

bool TestBit(int n) const { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); return IM_BITARRAY_TESTBIT(Storage, n); }

void SetBit(int n) { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArraySetBit(Storage, n); }

void ClearBit(int n) { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArrayClearBit(Storage, n); }

void SetBitRange(int n, int n2) { n += OFFSET; n2 += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT && n2 > n && n2 <= BITCOUNT); ImBitArraySetBitRange(Storage, n, n2); } // Works on range [n..n2)

bool operator[](int n) const { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); return IM_BITARRAY_TESTBIT(Storage, n); }

{

char* BasePtr;

int CurrOff;

int CurrIdx;

int Offsets[CHUNKS];

int Sizes[CHUNKS];

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

inline void Reserve(int n, size_t sz, int a=4) { IM_ASSERT(n == CurrIdx && n < CHUNKS); CurrOff = IM_MEMALIGN(CurrOff, a); Offsets[n] = CurrOff; Sizes[n] = (int)sz; CurrIdx++; CurrOff += (int)sz; }

inline int GetArenaSizeInBytes() { return CurrOff; }

inline void SetArenaBasePtr(void* base_ptr) { BasePtr = (char*)base_ptr; }

inline void* GetSpanPtrBegin(int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n]); }

inline void* GetSpanPtrEnd(int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n] + Sizes[n]); }

template<typename T>

inline void GetSpan(int n, ImSpan<T>* span) { span->set((T*)GetSpanPtrBegin(n), (T*)GetSpanPtrEnd(n)); }

{

int Size = 0;

int Capacity = 0;

ImVector<T*> Blocks;

// Functions

inline ~ImStableVector() { for (T* block : Blocks) IM_FREE(block); }

inline void clear() { Size = Capacity = 0; Blocks.clear_delete(); }

inline void resize(int new_size) { if (new_size > Capacity) reserve(new_size); Size = new_size; }

inline void reserve(int new_cap)

{

new_cap = IM_MEMALIGN(new_cap, BLOCK_SIZE);

int old_count = Capacity / BLOCK_SIZE;

int new_count = new_cap / BLOCK_SIZE;

if (new_count <= old_count)

return;

Blocks.resize(new_count);

for (int n = old_count; n < new_count; n++)

Blocks[n] = (T*)IM_ALLOC(sizeof(T) * BLOCK_SIZE);

Capacity = new_cap;

}

inline T& operator[](int i) { IM_ASSERT(i >= 0 && i < Size); return Blocks[i / BLOCK_SIZE][i % BLOCK_SIZE]; }

inline const T& operator[](int i) const { IM_ASSERT(i >= 0 && i < Size); return Blocks[i / BLOCK_SIZE][i % BLOCK_SIZE]; }

inline T* push_back(const T& v) { int i = Size; IM_ASSERT(i >= 0); if (Size == Capacity) reserve(Capacity + BLOCK_SIZE); void* ptr = &Blocks[i / BLOCK_SIZE][i % BLOCK_SIZE]; memcpy(ptr, &v, sizeof(v)); Size++; return (T*)ptr; }

{

ImVector<T> Buf; // Contiguous data

ImGuiStorage Map; // ID->Index

ImPoolIdx FreeIdx; // Next free idx to use

ImPoolIdx AliveCount; // Number of active/alive items (for display purpose)

ImPool() { FreeIdx = AliveCount = 0; }

~ImPool() { Clear(); }

T* GetByKey(ImGuiID key) { int idx = Map.GetInt(key, -1); return (idx != -1) ? &Buf[idx] : NULL; }

T* GetByIndex(ImPoolIdx n) { return &Buf[n]; }

ImPoolIdx GetIndex(const T* p) const { IM_ASSERT(p >= Buf.Data && p < Buf.Data + Buf.Size); return (ImPoolIdx)(p - Buf.Data); }

T* GetOrAddByKey(ImGuiID key) { int* p_idx = Map.GetIntRef(key, -1); if (*p_idx != -1) return &Buf[*p_idx]; *p_idx = FreeIdx; return Add(); }

bool Contains(const T* p) const { return (p >= Buf.Data && p < Buf.Data + Buf.Size); }

void Clear() { for (int n = 0; n < Map.Data.Size; n++) { int idx = Map.Data[n].val_i; if (idx != -1) Buf[idx].~T(); } Map.Clear(); Buf.clear(); FreeIdx = AliveCount = 0; }

T* Add() { int idx = FreeIdx; if (idx == Buf.Size) { Buf.resize(Buf.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Buf[idx]; } IM_PLACEMENT_NEW(&Buf[idx]) T(); AliveCount++; return &Buf[idx]; }

void Remove(ImGuiID key, const T* p) { Remove(key, GetIndex(p)); }

void Remove(ImGuiID key, ImPoolIdx idx) { Buf[idx].~T(); *(int*)&Buf[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); AliveCount--; }

void Reserve(int capacity) { Buf.reserve(capacity); Map.Data.reserve(capacity); }

// To iterate a ImPool: for (int n = 0; n < pool.GetMapSize(); n++) if (T* t = pool.TryGetMapData(n)) { ... }

// Can be avoided if you know .Remove() has never been called on the pool, or AliveCount == GetMapSize()

int GetAliveCount() const { return AliveCount; } // Number of active/alive items in the pool (for display purpose)

int GetBufSize() const { return Buf.Size; }

int GetMapSize() const { return Map.Data.Size; } // It is the map we need iterate to find valid items, since we don't have "alive" storage anywhere

T* TryGetMapData(ImPoolIdx n) { int idx = Map.Data[n].val_i; if (idx == -1) return NULL; return GetByIndex(idx); }

{

ImVector<char> Buf;

void clear() { Buf.clear(); }

bool empty() const { return Buf.Size == 0; }

int size() const { return Buf.Size; }

T* alloc_chunk(size_t sz) { size_t HDR_SZ = 4; sz = IM_MEMALIGN(HDR_SZ + sz, 4u); int off = Buf.Size; Buf.resize(off + (int)sz); ((int*)(void*)(Buf.Data + off))[0] = (int)sz; return (T*)(void*)(Buf.Data + off + (int)HDR_SZ); }

T* begin() { size_t HDR_SZ = 4; if (!Buf.Data) return NULL; return (T*)(void*)(Buf.Data + HDR_SZ); }

T* next_chunk(T* p) { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; }

int chunk_size(const T* p) { return ((const int*)p)[-1]; }

T* end() { return (T*)(void*)(Buf.Data + Buf.Size); }

int offset_from_ptr(const T* p) { IM_ASSERT(p >= begin() && p < end()); const ptrdiff_t off = (const char*)p - Buf.Data; return (int)off; }

T* ptr_from_offset(int off) { IM_ASSERT(off >= 4 && off < Buf.Size); return (T*)(void*)(Buf.Data + off); }

void swap(ImChunkStream<T>& rhs) { rhs.Buf.swap(Buf); }

{

ImVector<int> LineOffsets;

int EndOffset = 0; // Because we don't own text buffer we need to maintain EndOffset (may bake in LineOffsets?)

void clear() { LineOffsets.clear(); EndOffset = 0; }

int size() { return LineOffsets.Size; }

const char* get_line_begin(const char* base, int n) { return base + LineOffsets[n]; }

const char* get_line_end(const char* base, int n) { return base + (n + 1 < LineOffsets.Size ? (LineOffsets[n + 1] - 1) : EndOffset); }

void append(const char* base, int old_size, int new_size);

{

ImVector<ImDrawList*>* Layers[2]; // Pointers to global layers for: regular, tooltip. LayersP[0] is owned by DrawData.

ImVector<ImDrawList*> LayerData1;

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

{

ImFont* Font;

float FontSizeBeforeScaling; // ~~ style.FontSizeBase

float FontSizeAfterScaling; // ~~ g.FontSize

{

ImU32 Count : 8; // 1+

ImGuiDataType DataType : 8;

ImU32 Offset : 16; // Offset in parent structure

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

{

ImGuiCol Col;

ImVec4 BackupValue;

{

ImGuiStyleVar VarIdx;

union { int BackupInt[2]; float BackupFloat[2]; };

ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; }

ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; }

ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }

{

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

{

ImGuiDataType_Pointer = ImGuiDataType_COUNT,

ImGuiDataType_ID,

{

// Controlled by user

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_NoFocus = 1 << 17, // false // [EXPERIMENTAL: Not very well specced] Clicking doesn't take focus. Automatically sets ImGuiButtonFlags_NoFocus + ImGuiButtonFlags_NoNavFocus in ButtonBehavior().

// Controlled by widget code

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_None = 0,

ImGuiItemStatusFlags_HoveredRect = 1 << 0, // Mouse position is within item rectangle (does NOT mean that the window is in correct z-order and can be hovered!, this is only one part of the most-common IsItemHovered test)

ImGuiItemStatusFlags_HasDisplayRect = 1 << 1, // g.LastItemData.DisplayRect is valid

ImGuiItemStatusFlags_Edited = 1 << 2, // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)

ImGuiItemStatusFlags_ToggledSelection = 1 << 3, // Set when Selectable(), TreeNode() reports toggling a selection. We can't report "Selected", only state changes, in order to easily handle clipping with less issues.

ImGuiItemStatusFlags_ToggledOpen = 1 << 4, // Set when TreeNode() reports toggling their open state.

ImGuiItemStatusFlags_HasDeactivated = 1 << 5, // Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag.

ImGuiItemStatusFlags_Deactivated = 1 << 6, // Only valid if ImGuiItemStatusFlags_HasDeactivated is set.

ImGuiItemStatusFlags_HoveredWindow = 1 << 7, // Override the HoveredWindow test to allow cross-window hover testing.

ImGuiItemStatusFlags_Visible = 1 << 8, // [WIP] Set when item is overlapping the current clipping rectangle (Used internally. Please don't use yet: API/system will change as we refactor Itemadd()).

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

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

//ImGuiItemStatusFlags_FocusedByTabbing = 1 << 8, // Removed IN 1.90.1 (Dec 2023). The trigger is part of g.NavActivateId. See commit 54c1bdeceb.

// Additional status + semantic for ImGuiTestEngine

#ifdef IMGUI_ENABLE_TEST_ENGINE

ImGuiItemStatusFlags_Openable = 1 << 20, // Item is an openable (e.g. TreeNode)

ImGuiItemStatusFlags_Opened = 1 << 21, // Opened status

ImGuiItemStatusFlags_Checkable = 1 << 22, // Item is a checkable (e.g. CheckBox, MenuItem)

ImGuiItemStatusFlags_Checked = 1 << 23, // Checked status

ImGuiItemStatusFlags_Inputable = 1 << 24, // Item is a text-inputable (e.g. InputText, SliderXXX, DragXXX)

#endif

{

ImGuiHoveredFlags_DelayMask_ = ImGuiHoveredFlags_DelayNone | ImGuiHoveredFlags_DelayShort | ImGuiHoveredFlags_DelayNormal | ImGuiHoveredFlags_NoSharedDelay,

ImGuiHoveredFlags_AllowedMaskForIsWindowHovered = ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary,

ImGuiHoveredFlags_AllowedMaskForIsItemHovered = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayMask_,