Hide ProxySite

General (Auto) 🇺🇸 US 🇬🇧 UK 🇫🇷 FR Go

1	// dear imgui, v1.92.2b
2	// (internal structures/api)
3
4	// You may use this file to debug, understand or extend Dear ImGui features but we don't provide any guarantee of forward compatibility.
5
6	/*
7
8	Index of this file:
9
10	// [SECTION] Header mess
11	// [SECTION] Forward declarations
12	// [SECTION] Context pointer
13	// [SECTION] STB libraries includes
14	// [SECTION] Macros
15	// [SECTION] Generic helpers
16	// [SECTION] ImDrawList support
17	// [SECTION] Style support
18	// [SECTION] Data types support
19	// [SECTION] Widgets support: flags, enums, data structures
20	// [SECTION] Popup support
21	// [SECTION] Inputs support
22	// [SECTION] Clipper support
23	// [SECTION] Navigation support
24	// [SECTION] Typing-select support
25	// [SECTION] Columns support
26	// [SECTION] Box-select support
27	// [SECTION] Multi-select support
28	// [SECTION] Docking support
29	// [SECTION] Viewport support
30	// [SECTION] Settings support
31	// [SECTION] Localization support
32	// [SECTION] Error handling, State recovery support
33	// [SECTION] Metrics, Debug tools
34	// [SECTION] Generic context hooks
35	// [SECTION] ImGuiContext (main imgui context)
36	// [SECTION] ImGuiWindowTempData, ImGuiWindow
37	// [SECTION] Tab bar, Tab item support
38	// [SECTION] Table support
39	// [SECTION] ImGui internal API
40	// [SECTION] ImFontLoader
41	// [SECTION] ImFontAtlas internal API
42	// [SECTION] Test Engine specific hooks (imgui_test_engine)
43
44	*/
45
46	#pragma once
47	#ifndef IMGUI_DISABLE
48
49	//-----------------------------------------------------------------------------
50	// [SECTION] Header mess
51	//-----------------------------------------------------------------------------
52
53	#ifndef IMGUI_VERSION
54	#include "imgui.h"
55	#endif
56
57	#include <stdio.h> // FILE*, sscanf
58	#include <stdlib.h> // NULL, malloc, free, qsort, atoi, atof
59	#include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
60	#include <limits.h> // INT_MIN, INT_MAX
61
62	// Enable SSE intrinsics if available
63	#if (defined __SSE__ || defined __x86_64__ || defined _M_X64 || (defined(_M_IX86_FP) && (_M_IX86_FP >= 1))) && !defined(IMGUI_DISABLE_SSE)
64	#define IMGUI_ENABLE_SSE
65	#include <immintrin.h>
66	#if (defined __AVX__ || defined __SSE4_2__)
67	#define IMGUI_ENABLE_SSE4_2
68	#include <nmmintrin.h>
69	#endif
70	#endif
71	// Emscripten has partial SSE 4.2 support where _mm_crc32_u32 is not available. See https://emscripten.org/docs/porting/simd.html#id11 and #8213
72	#if defined(IMGUI_ENABLE_SSE4_2) && !defined(IMGUI_USE_LEGACY_CRC32_ADLER) && !defined(__EMSCRIPTEN__)
73	#define IMGUI_ENABLE_SSE4_2_CRC
74	#endif
75
76	// Visual Studio warnings
77	#ifdef _MSC_VER
78	#pragma warning (push)
79	#pragma warning (disable: 4251) // class 'xxx' needs to have dll-interface to be used by clients of struct 'xxx' // when IMGUI_API is set to__declspec(dllexport)
80	#pragma warning (disable: 26812) // The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3). [MSVC Static Analyzer)
81	#pragma warning (disable: 26495) // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6).
82	#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later
83	#pragma warning (disable: 5054) // operator '|': deprecated between enumerations of different types
84	#endif
85	#endif
86
87	// Clang/GCC warnings with -Weverything
88	#if defined(__clang__)
89	#pragma clang diagnostic push
90	#if __has_warning("-Wunknown-warning-option")
91	#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx'
92	#endif
93	#pragma clang diagnostic ignored "-Wunknown-pragmas" // warning: unknown warning group 'xxx'
94	#pragma clang diagnostic ignored "-Wfloat-equal" // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok, for ImFloor()
95	#pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast
96	#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" // warning: zero as null pointer constant
97	#pragma clang diagnostic ignored "-Wdouble-promotion" // warning: implicit conversion from 'float' to 'double' when passing argument to function
98	#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision
99	#pragma clang diagnostic ignored "-Wmissing-noreturn" // warning: function 'xxx' could be declared with attribute 'noreturn'
100	#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"// warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated
101	#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" // warning: 'xxx' is an unsafe pointer used for buffer access
102	#pragma clang diagnostic ignored "-Wnontrivial-memaccess" // warning: first argument in call to 'memset' is a pointer to non-trivially copyable type
103	#elif defined(__GNUC__)
104	#pragma GCC diagnostic push
105	#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind
106	#pragma GCC diagnostic ignored "-Wfloat-equal" // warning: comparing floating-point with '==' or '!=' is unsafe
107	#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
108	#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated
109	#endif
110
111	// In 1.89.4, we moved the implementation of "courtesy maths operators" from imgui_internal.h in imgui.h
112	// As they are frequently requested, we do not want to encourage to many people using imgui_internal.h
113	#if defined(IMGUI_DEFINE_MATH_OPERATORS) && !defined(IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED)
114	#error Please '#define IMGUI_DEFINE_MATH_OPERATORS' _BEFORE_ including imgui.h!
115	#endif
116
117	// Legacy defines
118	#ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS // Renamed in 1.74
119	#error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS
120	#endif
121	#ifdef IMGUI_DISABLE_MATH_FUNCTIONS // Renamed in 1.74
122	#error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
123	#endif
124
125	// Enable stb_truetype by default unless FreeType is enabled.
126	// You can compile with both by defining both IMGUI_ENABLE_FREETYPE and IMGUI_ENABLE_STB_TRUETYPE together.
127	#ifndef IMGUI_ENABLE_FREETYPE
128	#define IMGUI_ENABLE_STB_TRUETYPE
129	#endif
130
131	//-----------------------------------------------------------------------------
132	// [SECTION] Forward declarations
133	//-----------------------------------------------------------------------------
134
135	// Utilities
136	// (other types which are not forwarded declared are: ImBitArray<>, ImSpan<>, ImSpanAllocator<>, ImStableVector<>, ImPool<>, ImChunkStream<>)
137	struct ImBitVector; // Store 1-bit per value
138	struct ImRect; // An axis-aligned rectangle (2 points)
139	struct ImGuiTextIndex; // Maintain a line index for a text buffer.
140
141	// ImDrawList/ImFontAtlas
142	struct ImDrawDataBuilder; // Helper to build a ImDrawData instance
143	struct ImDrawListSharedData; // Data shared between all ImDrawList instances
144	struct ImFontAtlasBuilder; // Internal storage for incrementally packing and building a ImFontAtlas
145	struct ImFontAtlasPostProcessData; // Data available to potential texture post-processing functions
146	struct ImFontAtlasRectEntry; // Packed rectangle lookup entry
147
148	// ImGui
149	struct ImGuiBoxSelectState; // Box-selection state (currently used by multi-selection, could potentially be used by others)
150	struct ImGuiColorMod; // Stacked color modifier, backup of modified data so we can restore it
151	struct ImGuiContext; // Main Dear ImGui context
152	struct ImGuiContextHook; // Hook for extensions like ImGuiTestEngine
153	struct ImGuiDataTypeInfo; // Type information associated to a ImGuiDataType enum
154	struct ImGuiDeactivatedItemData; // Data for IsItemDeactivated()/IsItemDeactivatedAfterEdit() function.
155	struct ImGuiDockContext; // Docking system context
156	struct ImGuiDockRequest; // Docking system dock/undock queued request
157	struct ImGuiDockNode; // Docking system node (hold a list of Windows OR two child dock nodes)
158	struct ImGuiDockNodeSettings; // Storage for a dock node in .ini file (we preserve those even if the associated dock node isn't active during the session)
159	struct ImGuiErrorRecoveryState; // Storage of stack sizes for error handling and recovery
160	struct ImGuiGroupData; // Stacked storage data for BeginGroup()/EndGroup()
161	struct ImGuiInputTextState; // Internal state of the currently focused/edited text input box
162	struct ImGuiInputTextDeactivateData;// Short term storage to backup text of a deactivating InputText() while another is stealing active id
163	struct ImGuiLastItemData; // Status storage for last submitted items
164	struct ImGuiLocEntry; // A localization entry.
165	struct ImGuiMenuColumns; // Simple column measurement, currently used for MenuItem() only
166	struct ImGuiMultiSelectState; // Multi-selection persistent state (for focused selection).
167	struct ImGuiMultiSelectTempData; // Multi-selection temporary state (while traversing).
168	struct ImGuiNavItemData; // Result of a keyboard/gamepad directional navigation move query result
169	struct ImGuiMetricsConfig; // Storage for ShowMetricsWindow() and DebugNodeXXX() functions
170	struct ImGuiNextWindowData; // Storage for SetNextWindow** functions
171	struct ImGuiNextItemData; // Storage for SetNextItem** functions
172	struct ImGuiOldColumnData; // Storage data for a single column for legacy Columns() api
173	struct ImGuiOldColumns; // Storage data for a columns set for legacy Columns() api
174	struct ImGuiPopupData; // Storage for current popup stack
175	struct ImGuiSettingsHandler; // Storage for one type registered in the .ini file
176	struct ImGuiStyleMod; // Stacked style modifier, backup of modified data so we can restore it
177	struct ImGuiStyleVarInfo; // Style variable information (e.g. to access style variables from an enum)
178	struct ImGuiTabBar; // Storage for a tab bar
179	struct ImGuiTabItem; // Storage for a tab item (within a tab bar)
180	struct ImGuiTable; // Storage for a table
181	struct ImGuiTableHeaderData; // Storage for TableAngledHeadersRow()
182	struct ImGuiTableColumn; // Storage for one column of a table
183	struct ImGuiTableInstanceData; // Storage for one instance of a same table
184	struct ImGuiTableTempData; // Temporary storage for one table (one per table in the stack), shared between tables.
185	struct ImGuiTableSettings; // Storage for a table .ini settings
186	struct ImGuiTableColumnsSettings; // Storage for a column .ini settings
187	struct ImGuiTreeNodeStackData; // Temporary storage for TreeNode().
188	struct ImGuiTypingSelectState; // Storage for GetTypingSelectRequest()
189	struct ImGuiTypingSelectRequest; // Storage for GetTypingSelectRequest() (aimed to be public)
190	struct ImGuiWindow; // Storage for one window
191	struct ImGuiWindowDockStyle; // Storage for window-style data which needs to be stored for docking purpose
192	struct ImGuiWindowTempData; // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame, in practice we currently keep it for each window)
193	struct ImGuiWindowSettings; // Storage for a window .ini settings (we keep one of those even if the actual window wasn't instanced during this session)
194
195	// Enumerations
196	// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.
197	enum ImGuiLocKey : int; // -> enum ImGuiLocKey // Enum: a localization entry for translation.
198	typedef int ImGuiDataAuthority; // -> enum ImGuiDataAuthority_ // Enum: for storing the source authority (dock node vs window) of a field
199	typedef int ImGuiLayoutType; // -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical
200
201	// Flags
202	typedef int ImGuiActivateFlags; // -> enum ImGuiActivateFlags_ // Flags: for navigation/focus function (will be for ActivateItem() later)
203	typedef int ImGuiDebugLogFlags; // -> enum ImGuiDebugLogFlags_ // Flags: for ShowDebugLogWindow(), g.DebugLogFlags
204	typedef int ImGuiFocusRequestFlags; // -> enum ImGuiFocusRequestFlags_ // Flags: for FocusWindow()
205	typedef int ImGuiItemStatusFlags; // -> enum ImGuiItemStatusFlags_ // Flags: for g.LastItemData.StatusFlags
206	typedef int ImGuiOldColumnFlags; // -> enum ImGuiOldColumnFlags_ // Flags: for BeginColumns()
207	typedef int ImGuiLogFlags; // -> enum ImGuiLogFlags_ // Flags: for LogBegin() text capturing function
208	typedef int ImGuiNavRenderCursorFlags; // -> enum ImGuiNavRenderCursorFlags_//Flags: for RenderNavCursor()
209	typedef int ImGuiNavMoveFlags; // -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests
210	typedef int ImGuiNextItemDataFlags; // -> enum ImGuiNextItemDataFlags_ // Flags: for SetNextItemXXX() functions
211	typedef int ImGuiNextWindowDataFlags; // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions
212	typedef int ImGuiScrollFlags; // -> enum ImGuiScrollFlags_ // Flags: for ScrollToItem() and navigation requests
213	typedef int ImGuiSeparatorFlags; // -> enum ImGuiSeparatorFlags_ // Flags: for SeparatorEx()
214	typedef int ImGuiTextFlags; // -> enum ImGuiTextFlags_ // Flags: for TextEx()
215	typedef int ImGuiTooltipFlags; // -> enum ImGuiTooltipFlags_ // Flags: for BeginTooltipEx()
216	typedef int ImGuiTypingSelectFlags; // -> enum ImGuiTypingSelectFlags_ // Flags: for GetTypingSelectRequest()
217	typedef int ImGuiWindowRefreshFlags; // -> enum ImGuiWindowRefreshFlags_ // Flags: for SetNextWindowRefreshPolicy()
218
219	// Table column indexing
220	typedef ImS16 ImGuiTableColumnIdx;
221	typedef ImU16 ImGuiTableDrawChannelIdx;
222
223	//-----------------------------------------------------------------------------
224	// [SECTION] Context pointer
225	// See implementation of this variable in imgui.cpp for comments and details.
226	//-----------------------------------------------------------------------------
227
228	#ifndef GImGui
229	extern IMGUI_API ImGuiContext* GImGui; // Current implicit context pointer
230	#endif
231
232	//-----------------------------------------------------------------------------
233	// [SECTION] Macros
234	//-----------------------------------------------------------------------------
235
236	// Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui.
237	#define IMGUI_PAYLOAD_TYPE_WINDOW "_IMWINDOW" // Payload == ImGuiWindow*
238
239	// Debug Printing Into TTY
240	// (since IMGUI_VERSION_NUM >= 18729: IMGUI_DEBUG_LOG was reworked into IMGUI_DEBUG_PRINTF (and removed framecount from it). If you were using a #define IMGUI_DEBUG_LOG please rename)
241	#ifndef IMGUI_DEBUG_PRINTF
242	#ifndef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS
243	#define IMGUI_DEBUG_PRINTF(_FMT,...) printf(_FMT, __VA_ARGS__)
244	#else
245	#define IMGUI_DEBUG_PRINTF(_FMT,...) ((void)0)
246	#endif
247	#endif
248
249	// Debug Logging for ShowDebugLogWindow(). This is designed for relatively rare events so please don't spam.
250	#define IMGUI_DEBUG_LOG_ERROR(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventError) IMGUI_DEBUG_LOG(__VA_ARGS__); else g.DebugLogSkippedErrors++; } while (0)
251	#define IMGUI_DEBUG_LOG_ACTIVEID(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
252	#define IMGUI_DEBUG_LOG_FOCUS(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
253	#define IMGUI_DEBUG_LOG_POPUP(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
254	#define IMGUI_DEBUG_LOG_NAV(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
255	#define IMGUI_DEBUG_LOG_SELECTION(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
256	#define IMGUI_DEBUG_LOG_CLIPPER(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
257	#define IMGUI_DEBUG_LOG_IO(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
258	#define IMGUI_DEBUG_LOG_FONT(...) do { ImGuiContext* g2 = GImGui; if (g2 && g2->DebugLogFlags & ImGuiDebugLogFlags_EventFont) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) // Called from ImFontAtlas function which may operate without a context.
259	#define IMGUI_DEBUG_LOG_INPUTROUTING(...) do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
260	#define IMGUI_DEBUG_LOG_DOCKING(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
261	#define IMGUI_DEBUG_LOG_VIEWPORT(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)
262
263	// Static Asserts
264	#define IM_STATIC_ASSERT(_COND) static_assert(_COND, "")
265
266	// "Paranoid" Debug Asserts are meant to only be enabled during specific debugging/work, otherwise would slow down the code too much.
267	// We currently don't have many of those so the effect is currently negligible, but onward intent to add more aggressive ones in the code.
268	//#define IMGUI_DEBUG_PARANOID
269	#ifdef IMGUI_DEBUG_PARANOID
270	#define IM_ASSERT_PARANOID(_EXPR) IM_ASSERT(_EXPR)
271	#else
272	#define IM_ASSERT_PARANOID(_EXPR)
273	#endif
274
275	// Misc Macros
276	#define IM_PI 3.14159265358979323846f
277	#ifdef _WIN32
278	#define IM_NEWLINE "\r\n" // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!)
279	#else
280	#define IM_NEWLINE "\n"
281	#endif
282	#ifndef IM_TABSIZE // Until we move this to runtime and/or add proper tab support, at least allow users to compile-time override
283	#define IM_TABSIZE (4)
284	#endif
285	#define IM_MEMALIGN(_OFF,_ALIGN) (((_OFF) + ((_ALIGN) - 1)) & ~((_ALIGN) - 1)) // Memory align e.g. IM_ALIGN(0,4)=0, IM_ALIGN(1,4)=4, IM_ALIGN(4,4)=4, IM_ALIGN(5,4)=8
286	#define IM_F32_TO_INT8_UNBOUND(_VAL) ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f))) // Unsaturated, for display purpose
287	#define IM_F32_TO_INT8_SAT(_VAL) ((int)(ImSaturate(_VAL) * 255.0f + 0.5f)) // Saturated, always output 0..255
288	#define IM_TRUNC(_VAL) ((float)(int)(_VAL)) // ImTrunc() is not inlined in MSVC debug builds
289	#define IM_ROUND(_VAL) ((float)(int)((_VAL) + 0.5f)) //
290	#define IM_STRINGIFY_HELPER(_X) #_X
291	#define IM_STRINGIFY(_X) IM_STRINGIFY_HELPER(_X) // Preprocessor idiom to stringify e.g. an integer.
292	#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
293	#define IM_FLOOR IM_TRUNC
294	#endif
295
296	// Hint for branch prediction
297	#if (defined(__cplusplus) && (__cplusplus >= 202002L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L))
298	#define IM_LIKELY [[likely]]
299	#define IM_UNLIKELY [[unlikely]]
300	#else
301	#define IM_LIKELY
302	#define IM_UNLIKELY
303	#endif
304
305	// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
306	#ifdef _MSC_VER
307	#define IMGUI_CDECL __cdecl
308	#else
309	#define IMGUI_CDECL
310	#endif
311
312	// Warnings
313	#if defined(_MSC_VER) && !defined(__clang__)
314	#define IM_MSVC_WARNING_SUPPRESS(XXXX) __pragma(warning(suppress: XXXX))
315	#else
316	#define IM_MSVC_WARNING_SUPPRESS(XXXX)
317	#endif
318
319	// Debug Tools
320	// Use 'Metrics/Debugger->Tools->Item Picker' to break into the call-stack of a specific item.
321	// This will call IM_DEBUG_BREAK() which you may redefine yourself. See https://github.com/scottt/debugbreak for more reference.
322	#ifndef IM_DEBUG_BREAK
323	#if defined (_MSC_VER)
324	#define IM_DEBUG_BREAK() __debugbreak()
325	#elif defined(__clang__)
326	#define IM_DEBUG_BREAK() __builtin_debugtrap()
327	#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
328	#define IM_DEBUG_BREAK() __asm__ volatile("int3;nop")
329	#elif defined(__GNUC__) && defined(__thumb__)
330	#define IM_DEBUG_BREAK() __asm__ volatile(".inst 0xde01")
331	#elif defined(__GNUC__) && defined(__arm__) && !defined(__thumb__)
332	#define IM_DEBUG_BREAK() __asm__ volatile(".inst 0xe7f001f0")
333	#else
334	#define IM_DEBUG_BREAK() IM_ASSERT(0) // It is expected that you define IM_DEBUG_BREAK() into something that will break nicely in a debugger!
335	#endif
336	#endif // #ifndef IM_DEBUG_BREAK
337
338	// Format specifiers, printing 64-bit hasn't been decently standardized...
339	// In a real application you should be using PRId64 and PRIu64 from <inttypes.h> (non-windows) and on Windows define them yourself.
340	#if defined(_MSC_VER) && !defined(__clang__)
341	#define IM_PRId64 "I64d"
342	#define IM_PRIu64 "I64u"
343	#define IM_PRIX64 "I64X"
344	#else
345	#define IM_PRId64 "lld"
346	#define IM_PRIu64 "llu"
347	#define IM_PRIX64 "llX"
348	#endif
349
350	//-----------------------------------------------------------------------------
351	// [SECTION] Generic helpers
352	// Note that the ImXXX helpers functions are lower-level than ImGui functions.
353	// ImGui functions or the ImGui context are never called/used from other ImXXX functions.
354	//-----------------------------------------------------------------------------
355	// - Helpers: Hashing
356	// - Helpers: Sorting
357	// - Helpers: Bit manipulation
358	// - Helpers: String
359	// - Helpers: Formatting
360	// - Helpers: UTF-8 <> wchar conversions
361	// - Helpers: ImVec2/ImVec4 operators
362	// - Helpers: Maths
363	// - Helpers: Geometry
364	// - Helper: ImVec1
365	// - Helper: ImVec2ih
366	// - Helper: ImRect
367	// - Helper: ImBitArray
368	// - Helper: ImBitVector
369	// - Helper: ImSpan<>, ImSpanAllocator<>
370	// - Helper: ImStableVector<>
371	// - Helper: ImPool<>
372	// - Helper: ImChunkStream<>
373	// - Helper: ImGuiTextIndex
374	// - Helper: ImGuiStorage
375	//-----------------------------------------------------------------------------
376
377	// Helpers: Hashing
378	IMGUI_API ImGuiID ImHashData(const void* data, size_t data_size, ImGuiID seed = 0);
379	IMGUI_API ImGuiID ImHashStr(const char* data, size_t data_size = 0, ImGuiID seed = 0);
380
381	// Helpers: Sorting
382	#ifndef ImQsort
383	inline void ImQsort(void* base, size_t count, size_t size_of_element, int(IMGUI_CDECL *compare_func)(void const*, void const*)) { if (count > 1) qsort(base: base, nmemb: count, size: size_of_element, compar: compare_func); }
384	#endif
385
386	// Helpers: Color Blending
387	IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);
388
389	// Helpers: Bit manipulation
390	inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
391	inline bool ImIsPowerOfTwo(ImU64 v) { return v != 0 && (v & (v - 1)) == 0; }
392	inline int ImUpperPowerOfTwo(int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
393	inline unsigned int ImCountSetBits(unsigned int v) { unsigned int count = 0; while (v > 0) { v = v & (v - 1); count++; } return count; }
394
395	// Helpers: String
396	#define ImStrlen strlen
397	#define ImMemchr memchr
398	IMGUI_API int ImStricmp(const char* str1, const char* str2); // Case insensitive compare.
399	IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count); // Case insensitive compare to a certain count.
400	IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count); // Copy to a certain count and always zero terminate (strncpy doesn't).
401	IMGUI_API char* ImStrdup(const char* str); // Duplicate a string.
402	IMGUI_API void* ImMemdup(const void* src, size_t size); // Duplicate a chunk of memory.
403	IMGUI_API char* ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str); // Copy in provided buffer, recreate buffer if needed.
404	IMGUI_API const char* ImStrchrRange(const char* str_begin, const char* str_end, char c); // Find first occurrence of 'c' in string range.
405	IMGUI_API const char* ImStreolRange(const char* str, const char* str_end); // End end-of-line
406	IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end); // Find a substring in a string range.
407	IMGUI_API void ImStrTrimBlanks(char* str); // Remove leading and trailing blanks from a buffer.
408	IMGUI_API const char* ImStrSkipBlank(const char* str); // Find first non-blank character.
409	IMGUI_API int ImStrlenW(const ImWchar* str); // Computer string length (ImWchar string)
410	IMGUI_API const char* ImStrbol(const char* buf_mid_line, const char* buf_begin); // Find beginning-of-line
411	IM_MSVC_RUNTIME_CHECKS_OFF
412	inline char ImToUpper(char c) { return (c >= 'a' && c <= 'z') ? c &= ~32 : c; }
413	inline bool ImCharIsBlankA(char c) { return c == ' ' || c == '\t'; }
414	inline bool ImCharIsBlankW(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
415	inline bool ImCharIsXdigitA(char c) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); }
416	IM_MSVC_RUNTIME_CHECKS_RESTORE
417
418	// Helpers: Formatting
419	IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
420	IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
421	IMGUI_API void ImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...) IM_FMTARGS(3);
422	IMGUI_API void ImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args) IM_FMTLIST(3);
423	IMGUI_API const char* ImParseFormatFindStart(const char* format);
424	IMGUI_API const char* ImParseFormatFindEnd(const char* format);
425	IMGUI_API const char* ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);
426	IMGUI_API void ImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size);
427	IMGUI_API const char* ImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size);
428	IMGUI_API int ImParseFormatPrecision(const char* format, int default_value);
429
430	// Helpers: UTF-8 <> wchar conversions
431	IMGUI_API int ImTextCharToUtf8(char out_buf[5], unsigned int c); // return output UTF-8 bytes count
432	IMGUI_API int ImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count
433	IMGUI_API int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // read one character. return input UTF-8 bytes count
434	IMGUI_API int ImTextStrFromUtf8(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL); // return input UTF-8 bytes count
435	IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count)
436	IMGUI_API int ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end); // return number of bytes to express one char in UTF-8
437	IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string in UTF-8
438	IMGUI_API const char* ImTextFindPreviousUtf8Codepoint(const char* in_text_start, const char* in_text_curr); // return previous UTF-8 code-point.
439	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.
440
441	// Helpers: File System
442	#ifdef IMGUI_DISABLE_FILE_FUNCTIONS
443	#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
444	typedef void* ImFileHandle;
445	inline ImFileHandle ImFileOpen(const char*, const char*) { return NULL; }
446	inline bool ImFileClose(ImFileHandle) { return false; }
447	inline ImU64 ImFileGetSize(ImFileHandle) { return (ImU64)-1; }
448	inline ImU64 ImFileRead(void*, ImU64, ImU64, ImFileHandle) { return 0; }
449	inline ImU64 ImFileWrite(const void*, ImU64, ImU64, ImFileHandle) { return 0; }
450	#endif
451	#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
452	typedef FILE* ImFileHandle;
453	IMGUI_API ImFileHandle ImFileOpen(const char* filename, const char* mode);
454	IMGUI_API bool ImFileClose(ImFileHandle file);
455	IMGUI_API ImU64 ImFileGetSize(ImFileHandle file);
456	IMGUI_API ImU64 ImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file);
457	IMGUI_API ImU64 ImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file);
458	#else
459	#define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions
460	#endif
461	IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size = NULL, int padding_bytes = 0);
462
463	// Helpers: Maths
464	IM_MSVC_RUNTIME_CHECKS_OFF
465	// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)
466	#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
467	#define ImFabs(X) fabsf(X)
468	#define ImSqrt(X) sqrtf(X)
469	#define ImFmod(X, Y) fmodf((X), (Y))
470	#define ImCos(X) cosf(X)
471	#define ImSin(X) sinf(X)
472	#define ImAcos(X) acosf(X)
473	#define ImAtan2(Y, X) atan2f((Y), (X))
474	#define ImAtof(STR) atof(STR)
475	#define ImCeil(X) ceilf(X)
476	inline float ImPow(float x, float y) { return powf(x: x, y: y); } // DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision
477	inline double ImPow(double x, double y) { return pow(x: x, y: y); }
478	inline float ImLog(float x) { return logf(x: x); } // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision
479	inline double ImLog(double x) { return log(x: x); }
480	inline int ImAbs(int x) { return x < 0 ? -x : x; }
481	inline float ImAbs(float x) { return fabsf(x: x); }
482	inline double ImAbs(double x) { return fabs(x: x); }
483	inline float ImSign(float x) { return (x < 0.0f) ? -1.0f : (x > 0.0f) ? 1.0f : 0.0f; } // Sign operator - returns -1, 0 or 1 based on sign of argument
484	inline double ImSign(double x) { return (x < 0.0) ? -1.0 : (x > 0.0) ? 1.0 : 0.0; }
485	#ifdef IMGUI_ENABLE_SSE
486	inline float ImRsqrt(float x) { return _mm_cvtss_f32(a: _mm_rsqrt_ss(a: _mm_set_ss(w: x))); }
487	#else
488	inline float ImRsqrt(float x) { return 1.0f / sqrtf(x); }
489	#endif
490	inline double ImRsqrt(double x) { return 1.0 / sqrt(x: x); }
491	#endif
492	// - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support variety of types: signed/unsigned int/long long float/double
493	// (Exceptionally using templates here but we could also redefine them for those types)
494	template<typename T> T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; }
495	template<typename T> T ImMax(T lhs, T rhs) { return lhs >= rhs ? lhs : rhs; }
496	template<typename T> T ImClamp(T v, T mn, T mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
497	template<typename T> T ImLerp(T a, T b, float t) { return (T)(a + (b - a) * t); }
498	template<typename T> void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
499	template<typename T> T ImAddClampOverflow(T a, T b, T mn, T mx) { if (b < 0 && (a < mn - b)) return mn; if (b > 0 && (a > mx - b)) return mx; return a + b; }
500	template<typename T> T ImSubClampOverflow(T a, T b, T mn, T mx) { if (b > 0 && (a < mn + b)) return mn; if (b < 0 && (a > mx + b)) return mx; return a - b; }
501	// - Misc maths helpers
502	inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
503	inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
504	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); }
505	inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
506	inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
507	inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
508	inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
509	inline float ImLengthSqr(const ImVec2& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y); }
510	inline float ImLengthSqr(const ImVec4& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y) + (lhs.z * lhs.z) + (lhs.w * lhs.w); }
511	inline float ImInvLength(const ImVec2& lhs, float fail_value) { float d = (lhs.x * lhs.x) + (lhs.y * lhs.y); if (d > 0.0f) return ImRsqrt(x: d); return fail_value; }
512	inline float ImTrunc(float f) { return (float)(int)(f); }
513	inline ImVec2 ImTrunc(const ImVec2& v) { return ImVec2((float)(int)(v.x), (float)(int)(v.y)); }
514	inline float ImFloor(float f) { return (float)((f >= 0 || (float)(int)f == f) ? (int)f : (int)f - 1); } // Decent replacement for floorf()
515	inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2(ImFloor(f: v.x), ImFloor(f: v.y)); }
516	inline float ImTrunc64(float f) { return (float)(ImS64)(f); }
517	inline float ImRound64(float f) { return (float)(ImS64)(f + 0.5f); }
518	inline int ImModPositive(int a, int b) { return (a + b) % b; }
519	inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }
520	inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
521	inline float ImLinearSweep(float current, float target, float speed) { if (current < target) return ImMin(lhs: current + speed, rhs: target); if (current > target) return ImMax(lhs: current - speed, rhs: target); return current; }
522	inline float ImLinearRemapClamp(float s0, float s1, float d0, float d1, float x) { return ImSaturate(f: (x - s0) / (s1 - s0)) * (d1 - d0) + d0; }
523	inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
524	inline bool ImIsFloatAboveGuaranteedIntegerPrecision(float f) { return f <= -16777216 || f >= 16777216; }
525	inline float ImExponentialMovingAverage(float avg, float sample, int n){ avg -= avg / n; avg += sample / n; return avg; }
526	IM_MSVC_RUNTIME_CHECKS_RESTORE
527
528	// Helpers: Geometry
529	IMGUI_API ImVec2 ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t);
530	IMGUI_API ImVec2 ImBezierCubicClosestPoint(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& p, int num_segments); // For curves with explicit number of segments
531	IMGUI_API ImVec2 ImBezierCubicClosestPointCasteljau(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& p, float tess_tol);// For auto-tessellated curves you can use tess_tol = style.CurveTessellationTol
532	IMGUI_API ImVec2 ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t);
533	IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
534	IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
535	IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
536	IMGUI_API void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
537	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; }
538	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; }
539
540	// Helper: ImVec1 (1D vector)
541	// (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)
542	IM_MSVC_RUNTIME_CHECKS_OFF
543	struct ImVec1
544	{
545	float x;
546	constexpr ImVec1() : x(0.0f) { }
547	constexpr ImVec1(float _x) : x(_x) { }
548	};
549
550	// Helper: ImVec2i (2D vector, integer)
551	struct ImVec2i
552	{
553	int x, y;
554	constexpr ImVec2i() : x(0), y(0) {}
555	constexpr ImVec2i(int _x, int _y) : x(_x), y(_y) {}
556	};
557
558	// Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage)
559	struct ImVec2ih
560	{
561	short x, y;
562	constexpr ImVec2ih() : x(0), y(0) {}
563	constexpr ImVec2ih(short _x, short _y) : x(_x), y(_y) {}
564	constexpr explicit ImVec2ih(const ImVec2& rhs) : x((short)rhs.x), y((short)rhs.y) {}
565	};
566
567	// Helper: ImRect (2D axis aligned bounding-box)
568	// NB: we can't rely on ImVec2 math operators being available here!
569	struct IMGUI_API ImRect
570	{
571	ImVec2 Min; // Upper-left
572	ImVec2 Max; // Lower-right
573
574	constexpr ImRect() : Min(0.0f, 0.0f), Max(0.0f, 0.0f) {}
575	constexpr ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {}
576	constexpr ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {}
577	constexpr ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {}
578
579	ImVec2 GetCenter() const { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
580	ImVec2 GetSize() const { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
581	float GetWidth() const { return Max.x - Min.x; }
582	float GetHeight() const { return Max.y - Min.y; }
583	float GetArea() const { return (Max.x - Min.x) * (Max.y - Min.y); }
584	ImVec2 GetTL() const { return Min; } // Top-left
585	ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); } // Top-right
586	ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); } // Bottom-left
587	ImVec2 GetBR() const { return Max; } // Bottom-right
588	bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; }
589	bool Contains(const ImRect& r) const { return r.Min.x >= Min.x && r.Min.y >= Min.y && r.Max.x <= Max.x && r.Max.y <= Max.y; }
590	bool ContainsWithPad(const ImVec2& p, const ImVec2& pad) const { return p.x >= Min.x - pad.x && p.y >= Min.y - pad.y && p.x < Max.x + pad.x && p.y < Max.y + pad.y; }
591	bool Overlaps(const ImRect& r) const { return r.Min.y < Max.y && r.Max.y > Min.y && r.Min.x < Max.x && r.Max.x > Min.x; }
592	void Add(const ImVec2& p) { if (Min.x > p.x) Min.x = p.x; if (Min.y > p.y) Min.y = p.y; if (Max.x < p.x) Max.x = p.x; if (Max.y < p.y) Max.y = p.y; }
593	void Add(const ImRect& r) { if (Min.x > r.Min.x) Min.x = r.Min.x; if (Min.y > r.Min.y) Min.y = r.Min.y; if (Max.x < r.Max.x) Max.x = r.Max.x; if (Max.y < r.Max.y) Max.y = r.Max.y; }
594	void Expand(const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; }
595	void Expand(const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
596	void Translate(const ImVec2& d) { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }
597	void TranslateX(float dx) { Min.x += dx; Max.x += dx; }
598	void TranslateY(float dy) { Min.y += dy; Max.y += dy; }
599	void ClipWith(const ImRect& r) { Min = ImMax(lhs: Min, rhs: r.Min); Max = ImMin(lhs: Max, rhs: r.Max); } // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
600	void ClipWithFull(const ImRect& r) { Min = ImClamp(v: Min, mn: r.Min, mx: r.Max); Max = ImClamp(v: Max, mn: r.Min, mx: r.Max); } // Full version, ensure both points are fully clipped.
601	void Floor() { Min.x = IM_TRUNC(Min.x); Min.y = IM_TRUNC(Min.y); Max.x = IM_TRUNC(Max.x); Max.y = IM_TRUNC(Max.y); }
602	bool IsInverted() const { return Min.x > Max.x || Min.y > Max.y; }
603	ImVec4 ToVec4() const { return ImVec4(Min.x, Min.y, Max.x, Max.y); }
604	};
605
606	// Helper: ImBitArray
607	#define IM_BITARRAY_TESTBIT(_ARRAY, _N) ((_ARRAY[(_N) >> 5] & ((ImU32)1 << ((_N) & 31))) != 0) // Macro version of ImBitArrayTestBit(): ensure args have side-effect or are costly!
608	#define IM_BITARRAY_CLEARBIT(_ARRAY, _N) ((_ARRAY[(_N) >> 5] &= ~((ImU32)1 << ((_N) & 31)))) // Macro version of ImBitArrayClearBit(): ensure args have side-effect or are costly!
609	inline size_t ImBitArrayGetStorageSizeInBytes(int bitcount) { return (size_t)((bitcount + 31) >> 5) << 2; }
610	inline void ImBitArrayClearAllBits(ImU32* arr, int bitcount){ memset(s: arr, c: 0, n: ImBitArrayGetStorageSizeInBytes(bitcount)); }
611	inline bool ImBitArrayTestBit(const ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); return (arr[n >> 5] & mask) != 0; }
612	inline void ImBitArrayClearBit(ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] &= ~mask; }
613	inline void ImBitArraySetBit(ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] |= mask; }
614	inline void ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)
615	{
616	n2--;
617	while (n <= n2)
618	{
619	int a_mod = (n & 31);
620	int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
621	ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
622	arr[n >> 5] |= mask;
623	n = (n + 32) & ~31;
624	}
625	}
626
627	typedef ImU32* ImBitArrayPtr; // Name for use in structs
628
629	// Helper: ImBitArray class (wrapper over ImBitArray functions)
630	// Store 1-bit per value.
631	template<int BITCOUNT, int OFFSET = 0>
632	struct ImBitArray
633	{
634	ImU32 Storage[(BITCOUNT + 31) >> 5];
635	ImBitArray() { ClearAllBits(); }
636	void ClearAllBits() { memset(Storage, 0, sizeof(Storage)); }
637	void SetAllBits() { memset(Storage, 255, sizeof(Storage)); }
638	bool TestBit(int n) const { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); return IM_BITARRAY_TESTBIT(Storage, n); }
639	void SetBit(int n) { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArraySetBit(Storage, n); }
640	void ClearBit(int n) { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArrayClearBit(Storage, n); }
641	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)
642	bool operator[](int n) const { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); return IM_BITARRAY_TESTBIT(Storage, n); }
643	};
644
645	// Helper: ImBitVector
646	// Store 1-bit per value.
647	struct IMGUI_API ImBitVector
648	{
649	ImVector<ImU32> Storage;
650	void Create(int sz) { Storage.resize(new_size: (sz + 31) >> 5); memset(s: Storage.Data, c: 0, n: (size_t)Storage.Size * sizeof(Storage.Data[0])); }
651	void Clear() { Storage.clear(); }
652	bool TestBit(int n) const { IM_ASSERT(n < (Storage.Size << 5)); return IM_BITARRAY_TESTBIT(Storage.Data, n); }
653	void SetBit(int n) { IM_ASSERT(n < (Storage.Size << 5)); ImBitArraySetBit(arr: Storage.Data, n); }
654	void ClearBit(int n) { IM_ASSERT(n < (Storage.Size << 5)); ImBitArrayClearBit(arr: Storage.Data, n); }
655	};
656	IM_MSVC_RUNTIME_CHECKS_RESTORE
657
658	// Helper: ImSpan<>
659	// Pointing to a span of data we don't own.
660	template<typename T>
661	struct ImSpan
662	{
663	T* Data;
664	T* DataEnd;
665
666	// Constructors, destructor
667	inline ImSpan() { Data = DataEnd = NULL; }
668	inline ImSpan(T* data, int size) { Data = data; DataEnd = data + size; }
669	inline ImSpan(T* data, T* data_end) { Data = data; DataEnd = data_end; }
670
671	inline void set(T* data, int size) { Data = data; DataEnd = data + size; }
672	inline void set(T* data, T* data_end) { Data = data; DataEnd = data_end; }
673	inline int size() const { return (int)(ptrdiff_t)(DataEnd - Data); }
674	inline int size_in_bytes() const { return (int)(ptrdiff_t)(DataEnd - Data) * (int)sizeof(T); }
675	inline T& operator[](int i) { T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }
676	inline const T& operator[](int i) const { const T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }
677
678	inline T* begin() { return Data; }
679	inline const T* begin() const { return Data; }
680	inline T* end() { return DataEnd; }
681	inline const T* end() const { return DataEnd; }
682
683	// Utilities
684	inline int index_from_ptr(const T* it) const { IM_ASSERT(it >= Data && it < DataEnd); const ptrdiff_t off = it - Data; return (int)off; }
685	};
686
687	// Helper: ImSpanAllocator<>
688	// Facilitate storing multiple chunks into a single large block (the "arena")
689	// - Usage: call Reserve() N times, allocate GetArenaSizeInBytes() worth, pass it to SetArenaBasePtr(), call GetSpan() N times to retrieve the aligned ranges.
690	template<int CHUNKS>
691	struct ImSpanAllocator
692	{
693	char* BasePtr;
694	int CurrOff;
695	int CurrIdx;
696	int Offsets[CHUNKS];
697	int Sizes[CHUNKS];
698
699	ImSpanAllocator() { memset(this, 0, sizeof(*this)); }
700	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; }
701	inline int GetArenaSizeInBytes() { return CurrOff; }
702	inline void SetArenaBasePtr(void* base_ptr) { BasePtr = (char*)base_ptr; }
703	inline void* GetSpanPtrBegin(int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n]); }
704	inline void* GetSpanPtrEnd(int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n] + Sizes[n]); }
705	template<typename T>
706	inline void GetSpan(int n, ImSpan<T>* span) { span->set((T*)GetSpanPtrBegin(n), (T*)GetSpanPtrEnd(n)); }
707	};
708
709	// Helper: ImStableVector<>
710	// Allocating chunks of BLOCK_SIZE items. Objects pointers are never invalidated when growing, only by clear().
711	// Important: does not destruct anything!
712	// Implemented only the minimum set of functions we need for it.
713	template<typename T, int BLOCK_SIZE>
714	struct ImStableVector
715	{
716	int Size = 0;
717	int Capacity = 0;
718	ImVector<T*> Blocks;
719
720	// Functions
721	inline ~ImStableVector() { for (T* block : Blocks) IM_FREE(block); }
722
723	inline void clear() { Size = Capacity = 0; Blocks.clear_delete(); }
724	inline void resize(int new_size) { if (new_size > Capacity) reserve(new_cap: new_size); Size = new_size; }
725	inline void reserve(int new_cap)
726	{
727	new_cap = IM_MEMALIGN(new_cap, BLOCK_SIZE);
728	int old_count = Capacity / BLOCK_SIZE;
729	int new_count = new_cap / BLOCK_SIZE;
730	if (new_count <= old_count)
731	return;
732	Blocks.resize(new_count);
733	for (int n = old_count; n < new_count; n++)
734	Blocks[n] = (T*)IM_ALLOC(sizeof(T) * BLOCK_SIZE);
735	Capacity = new_cap;
736	}
737	inline T& operator[](int i) { IM_ASSERT(i >= 0 && i < Size); return Blocks[i / BLOCK_SIZE][i % BLOCK_SIZE]; }
738	inline const T& operator[](int i) const { IM_ASSERT(i >= 0 && i < Size); return Blocks[i / BLOCK_SIZE][i % BLOCK_SIZE]; }
739	inline T* push_back(const T& v) { int i = Size; IM_ASSERT(i >= 0); if (Size == Capacity) reserve(new_cap: Capacity + BLOCK_SIZE); void* ptr = &Blocks[i / BLOCK_SIZE][i % BLOCK_SIZE]; memcpy(ptr, &v, sizeof(v)); Size++; return (T*)ptr; }
740	};
741
742	// Helper: ImPool<>
743	// Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer,
744	// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object.
745	typedef int ImPoolIdx;
746	template<typename T>
747	struct ImPool
748	{
749	ImVector<T> Buf; // Contiguous data
750	ImGuiStorage Map; // ID->Index
751	ImPoolIdx FreeIdx; // Next free idx to use
752	ImPoolIdx AliveCount; // Number of active/alive items (for display purpose)
753
754	ImPool() { FreeIdx = AliveCount = 0; }
755	~ImPool() { Clear(); }
756	T* GetByKey(ImGuiID key) { int idx = Map.GetInt(key, default_val: -1); return (idx != -1) ? &Buf[idx] : NULL; }
757	T* GetByIndex(ImPoolIdx n) { return &Buf[n]; }
758	ImPoolIdx GetIndex(const T* p) const { IM_ASSERT(p >= Buf.Data && p < Buf.Data + Buf.Size); return (ImPoolIdx)(p - Buf.Data); }
759	T* GetOrAddByKey(ImGuiID key) { int* p_idx = Map.GetIntRef(key, default_val: -1); if (*p_idx != -1) return &Buf[*p_idx]; *p_idx = FreeIdx; return Add(); }
760	bool Contains(const T* p) const { return (p >= Buf.Data && p < Buf.Data + Buf.Size); }
761	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; }
762	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]; }
763	void Remove(ImGuiID key, const T* p) { Remove(key, GetIndex(p)); }
764	void Remove(ImGuiID key, ImPoolIdx idx) { Buf[idx].~T(); *(int*)&Buf[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, val: -1); AliveCount--; }
765	void Reserve(int capacity) { Buf.reserve(capacity); Map.Data.reserve(new_capacity: capacity); }
766
767	// To iterate a ImPool: for (int n = 0; n < pool.GetMapSize(); n++) if (T* t = pool.TryGetMapData(n)) { ... }
768	// Can be avoided if you know .Remove() has never been called on the pool, or AliveCount == GetMapSize()
769	int GetAliveCount() const { return AliveCount; } // Number of active/alive items in the pool (for display purpose)
770	int GetBufSize() const { return Buf.Size; }
771	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
772	T* TryGetMapData(ImPoolIdx n) { int idx = Map.Data[n].val_i; if (idx == -1) return NULL; return GetByIndex(n: idx); }
773	};
774
775	// Helper: ImChunkStream<>
776	// Build and iterate a contiguous stream of variable-sized structures.
777	// This is used by Settings to store persistent data while reducing allocation count.
778	// We store the chunk size first, and align the final size on 4 bytes boundaries.
779	// The tedious/zealous amount of casting is to avoid -Wcast-align warnings.
780	template<typename T>
781	struct ImChunkStream
782	{
783	ImVector<char> Buf;
784
785	void clear() { Buf.clear(); }
786	bool empty() const { return Buf.Size == 0; }
787	int size() const { return Buf.Size; }
788	T* alloc_chunk(size_t sz) { size_t HDR_SZ = 4; sz = IM_MEMALIGN(HDR_SZ + sz, 4u); int off = Buf.Size; Buf.resize(new_size: off + (int)sz); ((int*)(void*)(Buf.Data + off))[0] = (int)sz; return (T*)(void*)(Buf.Data + off + (int)HDR_SZ); }
789	T* begin() { size_t HDR_SZ = 4; if (!Buf.Data) return NULL; return (T*)(void*)(Buf.Data + HDR_SZ); }
790	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; }
791	int chunk_size(const T* p) { return ((const int*)p)[-1]; }
792	T* end() { return (T*)(void*)(Buf.Data + Buf.Size); }
793	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; }
794	T* ptr_from_offset(int off) { IM_ASSERT(off >= 4 && off < Buf.Size); return (T*)(void*)(Buf.Data + off); }
795	void swap(ImChunkStream<T>& rhs) { rhs.Buf.swap(rhs&: Buf); }
796	};
797
798	// Helper: ImGuiTextIndex
799	// Maintain a line index for a text buffer. This is a strong candidate to be moved into the public API.
800	struct ImGuiTextIndex
801	{
802	ImVector<int> LineOffsets;
803	int EndOffset = 0; // Because we don't own text buffer we need to maintain EndOffset (may bake in LineOffsets?)
804
805	void clear() { LineOffsets.clear(); EndOffset = 0; }
806	int size() { return LineOffsets.Size; }
807	const char* get_line_begin(const char* base, int n) { return base + LineOffsets[n]; }
808	const char* get_line_end(const char* base, int n) { return base + (n + 1 < LineOffsets.Size ? (LineOffsets[n + 1] - 1) : EndOffset); }
809	void append(const char* base, int old_size, int new_size);
810	};
811
812	// Helper: ImGuiStorage
813	IMGUI_API ImGuiStoragePair* ImLowerBound(ImGuiStoragePair* in_begin, ImGuiStoragePair* in_end, ImGuiID key);
814
815	//-----------------------------------------------------------------------------
816	// [SECTION] ImDrawList support
817	//-----------------------------------------------------------------------------
818
819	// ImDrawList: Helper function to calculate a circle's segment count given its radius and a "maximum error" value.
820	// Estimation of number of circle segment based on error is derived using method described in https://stackoverflow.com/a/2244088/15194693
821	// Number of segments (N) is calculated using equation:
822	// N = ceil ( pi / acos(1 - error / r) ) where r > 0, error <= r
823	// Our equation is significantly simpler that one in the post thanks for choosing segment that is
824	// perpendicular to X axis. Follow steps in the article from this starting condition and you will
825	// will get this result.
826	//
827	// Rendering circles with an odd number of segments, while mathematically correct will produce
828	// asymmetrical results on the raster grid. Therefore we're rounding N to next even number (7->8, 8->8, 9->10 etc.)
829	#define IM_ROUNDUP_TO_EVEN(_V) ((((_V) + 1) / 2) * 2)
830	#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN 4
831	#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX 512
832	#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(_RAD,_MAXERROR) ImClamp(IM_ROUNDUP_TO_EVEN((int)ImCeil(IM_PI / ImAcos(1 - ImMin((_MAXERROR), (_RAD)) / (_RAD)))), IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX)
833
834	// Raw equation from IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC rewritten for 'r' and 'error'.
835	#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR) ((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))))
836	#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD) ((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD))
837
838	// ImDrawList: Lookup table size for adaptive arc drawing, cover full circle.
839	#ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE
840	#define IM_DRAWLIST_ARCFAST_TABLE_SIZE 48 // Number of samples in lookup table.
841	#endif
842	#define IM_DRAWLIST_ARCFAST_SAMPLE_MAX IM_DRAWLIST_ARCFAST_TABLE_SIZE // Sample index _PathArcToFastEx() for 360 angle.
843
844	// Data shared between all ImDrawList instances
845	// Conceptually this could have been called e.g. ImDrawListSharedContext
846	// Typically one ImGui context would create and maintain one of this.
847	// You may want to create your own instance of you try to ImDrawList completely without ImGui. In that case, watch out for future changes to this structure.
848	struct IMGUI_API ImDrawListSharedData
849	{
850	ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas (== FontAtlas->TexUvWhitePixel)
851	const ImVec4* TexUvLines; // UV of anti-aliased lines in the atlas (== FontAtlas->TexUvLines)
852	ImFontAtlas* FontAtlas; // Current font atlas
853	ImFont* Font; // Current font (used for simplified AddText overload)
854	float FontSize; // Current font size (used for for simplified AddText overload)
855	float FontScale; // Current font scale (== FontSize / Font->FontSize)
856	float CurveTessellationTol; // Tessellation tolerance when using PathBezierCurveTo()
857	float CircleSegmentMaxError; // Number of circle segments to use per pixel of radius for AddCircle() etc
858	float InitialFringeScale; // Initial scale to apply to AA fringe
859	ImDrawListFlags InitialFlags; // Initial flags at the beginning of the frame (it is possible to alter flags on a per-drawlist basis afterwards)
860	ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen()
861	ImVector<ImVec2> TempBuffer; // Temporary write buffer
862	ImVector<ImDrawList*> DrawLists; // All draw lists associated to this ImDrawListSharedData
863	ImGuiContext* Context; // [OPTIONAL] Link to Dear ImGui context. 99% of ImDrawList/ImFontAtlas can function without an ImGui context, but this facilitate handling one legacy edge case.
864
865	// Lookup tables
866	ImVec2 ArcFastVtx[IM_DRAWLIST_ARCFAST_TABLE_SIZE]; // Sample points on the quarter of the circle.
867	float ArcFastRadiusCutoff; // Cutoff radius after which arc drawing will fallback to slower PathArcTo()
868	ImU8 CircleSegmentCounts[64]; // Precomputed segment count for given radius before we calculate it dynamically (to avoid calculation overhead)
869
870	ImDrawListSharedData();
871	~ImDrawListSharedData();
872	void SetCircleTessellationMaxError(float max_error);
873	};
874
875	struct ImDrawDataBuilder
876	{
877	ImVector<ImDrawList*>* Layers[2]; // Pointers to global layers for: regular, tooltip. LayersP[0] is owned by DrawData.
878	ImVector<ImDrawList*> LayerData1;
879
880	ImDrawDataBuilder() { memset(s: this, c: 0, n: sizeof(*this)); }
881	};
882
883	struct ImFontStackData
884	{
885	ImFont* Font;
886	float FontSizeBeforeScaling; // ~~ style.FontSizeBase
887	float FontSizeAfterScaling; // ~~ g.FontSize
888	};
889
890	//-----------------------------------------------------------------------------
891	// [SECTION] Style support
892	//-----------------------------------------------------------------------------
893
894	struct ImGuiStyleVarInfo
895	{
896	ImU32 Count : 8; // 1+
897	ImGuiDataType DataType : 8;
898	ImU32 Offset : 16; // Offset in parent structure
899	void* GetVarPtr(void* parent) const { return (void*)((unsigned char*)parent + Offset); }
900	};
901
902	// Stacked color modifier, backup of modified data so we can restore it
903	struct ImGuiColorMod
904	{
905	ImGuiCol Col;
906	ImVec4 BackupValue;
907	};
908
909	// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
910	struct ImGuiStyleMod
911	{
912	ImGuiStyleVar VarIdx;
913	union { int BackupInt[2]; float BackupFloat[2]; };
914	ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; }
915	ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; }
916	ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }
917	};
918
919	//-----------------------------------------------------------------------------
920	// [SECTION] Data types support
921	//-----------------------------------------------------------------------------
922
923	struct ImGuiDataTypeStorage
924	{
925	ImU8 Data[8]; // Opaque storage to fit any data up to ImGuiDataType_COUNT
926	};
927
928	// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo().
929	struct ImGuiDataTypeInfo
930	{
931	size_t Size; // Size in bytes
932	const char* Name; // Short descriptive name for the type, for debugging
933	const char* PrintFmt; // Default printf format for the type
934	const char* ScanFmt; // Default scanf format for the type
935	};
936
937	// Extend ImGuiDataType_
938	enum ImGuiDataTypePrivate_
939	{
940	ImGuiDataType_Pointer = ImGuiDataType_COUNT,
941	ImGuiDataType_ID,
942	};
943
944	//-----------------------------------------------------------------------------
945	// [SECTION] Widgets support: flags, enums, data structures
946	//-----------------------------------------------------------------------------
947
948	// Extend ImGuiItemFlags
949	// - input: PushItemFlag() manipulates g.CurrentItemFlags, g.NextItemData.ItemFlags, ItemAdd() calls may add extra flags too.
950	// - output: stored in g.LastItemData.ItemFlags
951	enum ImGuiItemFlagsPrivate_
952	{
953	// Controlled by user
954	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).
955	ImGuiItemFlags_ReadOnly = 1 << 11, // false // [ALPHA] Allow hovering interactions but underlying value is not changed.
956	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)
957	ImGuiItemFlags_NoWindowHoverableCheck = 1 << 13, // false // Disable hoverable check in ItemHoverable()
958	ImGuiItemFlags_AllowOverlap = 1 << 14, // false // Allow being overlapped by another widget. Not-hovered to Hovered transition deferred by a frame.
959	ImGuiItemFlags_NoNavDisableMouseHover = 1 << 15, // false // Nav keyboard/gamepad mode doesn't disable hover highlight (behave as if NavHighlightItemUnderNav==false).
960	ImGuiItemFlags_NoMarkEdited = 1 << 16, // false // Skip calling MarkItemEdited()
961	ImGuiItemFlags_NoFocus = 1 << 17, // false // [EXPERIMENTAL: Not very well specced] Clicking doesn't take focus. Automatically sets ImGuiButtonFlags_NoFocus + ImGuiButtonFlags_NoNavFocus in ButtonBehavior().
962
963	// Controlled by widget code
964	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.
965	ImGuiItemFlags_HasSelectionUserData = 1 << 21, // false // Set by SetNextItemSelectionUserData()
966	ImGuiItemFlags_IsMultiSelect = 1 << 22, // false // Set by SetNextItemSelectionUserData()
967
968	ImGuiItemFlags_Default_ = ImGuiItemFlags_AutoClosePopups, // Please don't change, use PushItemFlag() instead.
969
970	// Obsolete
971	//ImGuiItemFlags_SelectableDontClosePopup = !ImGuiItemFlags_AutoClosePopups, // Can't have a redirect as we inverted the behavior
972	};
973
974	// Status flags for an already submitted item
975	// - output: stored in g.LastItemData.StatusFlags
976	enum ImGuiItemStatusFlags_
977	{
978	ImGuiItemStatusFlags_None = 0,
979	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)
980	ImGuiItemStatusFlags_HasDisplayRect = 1 << 1, // g.LastItemData.DisplayRect is valid
981	ImGuiItemStatusFlags_Edited = 1 << 2, // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
982	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.
983	ImGuiItemStatusFlags_ToggledOpen = 1 << 4, // Set when TreeNode() reports toggling their open state.
984	ImGuiItemStatusFlags_HasDeactivated = 1 << 5, // Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag.
985	ImGuiItemStatusFlags_Deactivated = 1 << 6, // Only valid if ImGuiItemStatusFlags_HasDeactivated is set.
986	ImGuiItemStatusFlags_HoveredWindow = 1 << 7, // Override the HoveredWindow test to allow cross-window hover testing.
987	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()).
988	ImGuiItemStatusFlags_HasClipRect = 1 << 9, // g.LastItemData.ClipRect is valid.
989	ImGuiItemStatusFlags_HasShortcut = 1 << 10, // g.LastItemData.Shortcut valid. Set by SetNextItemShortcut() -> ItemAdd().
990	//ImGuiItemStatusFlags_FocusedByTabbing = 1 << 8, // Removed IN 1.90.1 (Dec 2023). The trigger is part of g.NavActivateId. See commit 54c1bdeceb.
991
992	// Additional status + semantic for ImGuiTestEngine
993	#ifdef IMGUI_ENABLE_TEST_ENGINE
994	ImGuiItemStatusFlags_Openable = 1 << 20, // Item is an openable (e.g. TreeNode)
995	ImGuiItemStatusFlags_Opened = 1 << 21, // Opened status
996	ImGuiItemStatusFlags_Checkable = 1 << 22, // Item is a checkable (e.g. CheckBox, MenuItem)
997	ImGuiItemStatusFlags_Checked = 1 << 23, // Checked status
998	ImGuiItemStatusFlags_Inputable = 1 << 24, // Item is a text-inputable (e.g. InputText, SliderXXX, DragXXX)
999	#endif
1000	};
1001
1002	// Extend ImGuiHoveredFlags_
1003	enum ImGuiHoveredFlagsPrivate_
1004	{
1005	ImGuiHoveredFlags_DelayMask_ = ImGuiHoveredFlags_DelayNone | ImGuiHoveredFlags_DelayShort | ImGuiHoveredFlags_DelayNormal | ImGuiHoveredFlags_NoSharedDelay,
1006	ImGuiHoveredFlags_AllowedMaskForIsWindowHovered = ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_DockHierarchy | ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary,
1007	ImGuiHoveredFlags_AllowedMaskForIsItemHovered = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayMask_,
1008	};
1009
1010	// Extend ImGuiInputTextFlags_
1011	enum ImGuiInputTextFlagsPrivate_
1012	{
1013	// [Internal]
1014	ImGuiInputTextFlags_Multiline = 1 << 26, // For internal use by InputTextMultiline()
1015	ImGuiInputTextFlags_MergedItem = 1 << 27, // For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match.
1016	ImGuiInputTextFlags_LocalizeDecimalPoint= 1 << 28, // For internal use by InputScalar() and TempInputScalar()
1017	};
1018
1019	// Extend ImGuiButtonFlags_
1020	enum ImGuiButtonFlagsPrivate_
1021	{
1022	ImGuiButtonFlags_PressedOnClick = 1 << 4, // return true on click (mouse down event)
1023	ImGuiButtonFlags_PressedOnClickRelease = 1 << 5, // [Default] return true on click + release on same item <-- this is what the majority of Button are using
1024	ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 1 << 6, // return true on click + release even if the release event is not done while hovering the item
1025	ImGuiButtonFlags_PressedOnRelease = 1 << 7, // return true on release (default requires click+release)
1026	ImGuiButtonFlags_PressedOnDoubleClick = 1 << 8, // return true on double-click (default requires click+release)
1027	ImGuiButtonFlags_PressedOnDragDropHold = 1 << 9, // return true when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
1028	//ImGuiButtonFlags_Repeat = 1 << 10, // hold to repeat -> use ImGuiItemFlags_ButtonRepeat instead.
1029	ImGuiButtonFlags_FlattenChildren = 1 << 11, // allow interactions even if a child window is overlapping
1030	ImGuiButtonFlags_AllowOverlap = 1 << 12, // require previous frame HoveredId to either match id or be null before being usable.
1031	//ImGuiButtonFlags_DontClosePopups = 1 << 13, // disable automatically closing parent popup on press
1032	//ImGuiButtonFlags_Disabled = 1 << 14, // disable interactions -> use BeginDisabled() or ImGuiItemFlags_Disabled
1033	ImGuiButtonFlags_AlignTextBaseLine = 1 << 15, // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
1034	ImGuiButtonFlags_NoKeyModsAllowed = 1 << 16, // disable mouse interaction if a key modifier is held
1035	ImGuiButtonFlags_NoHoldingActiveId = 1 << 17, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
1036	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)
1037	ImGuiButtonFlags_NoHoveredOnFocus = 1 << 19, // don't report as hovered when nav focus is on this item
1038	ImGuiButtonFlags_NoSetKeyOwner = 1 << 20, // don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)
1039	ImGuiButtonFlags_NoTestKeyOwner = 1 << 21, // don't test key/input owner when polling the key (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)
1040	ImGuiButtonFlags_NoFocus = 1 << 22, // [EXPERIMENTAL: Not very well specced]. Don't focus parent window when clicking.
1041	ImGuiButtonFlags_PressedOnMask_ = ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold,
1042	ImGuiButtonFlags_PressedOnDefault_ = ImGuiButtonFlags_PressedOnClickRelease,
1043	//ImGuiButtonFlags_NoKeyModifiers = ImGuiButtonFlags_NoKeyModsAllowed, // Renamed in 1.91.4
1044	};
1045
1046	// Extend ImGuiComboFlags_
1047	enum ImGuiComboFlagsPrivate_
1048	{
1049	ImGuiComboFlags_CustomPreview = 1 << 20, // enable BeginComboPreview()
1050	};
1051
1052	// Extend ImGuiSliderFlags_
1053	enum ImGuiSliderFlagsPrivate_
1054	{
1055	ImGuiSliderFlags_Vertical = 1 << 20, // Should this slider be orientated vertically?
1056	ImGuiSliderFlags_ReadOnly = 1 << 21, // Consider using g.NextItemData.ItemFlags |= ImGuiItemFlags_ReadOnly instead.
1057	};
1058
1059	// Extend ImGuiSelectableFlags_
1060	enum ImGuiSelectableFlagsPrivate_
1061	{
1062	// NB: need to be in sync with last value of ImGuiSelectableFlags_
1063	ImGuiSelectableFlags_NoHoldingActiveID = 1 << 20,
1064	ImGuiSelectableFlags_SelectOnNav = 1 << 21, // (WIP) Auto-select when moved into. This is not exposed in public API as to handle multi-select and modifiers we will need user to explicitly control focus scope. May be replaced with a BeginSelection() API.
1065	ImGuiSelectableFlags_SelectOnClick = 1 << 22, // Override button behavior to react on Click (default is Click+Release)
1066	ImGuiSelectableFlags_SelectOnRelease = 1 << 23, // Override button behavior to react on Release (default is Click+Release)
1067	ImGuiSelectableFlags_SpanAvailWidth = 1 << 24, // Span all avail width even if we declared less for layout purpose. FIXME: We may be able to remove this (added in 6251d379, 2bcafc86 for menus)
1068	ImGuiSelectableFlags_SetNavIdOnHover = 1 << 25, // Set Nav/Focus ID on mouse hover (used by MenuItem)
1069	ImGuiSelectableFlags_NoPadWithHalfSpacing = 1 << 26, // Disable padding each side with ItemSpacing * 0.5f
1070	ImGuiSelectableFlags_NoSetKeyOwner = 1 << 27, // Don't set key/input owner on the initial click (note: mouse buttons are keys! often, the key in question will be ImGuiKey_MouseLeft!)
1071	};
1072
1073	// Extend ImGuiTreeNodeFlags_
1074	enum ImGuiTreeNodeFlagsPrivate_
1075	{
1076	ImGuiTreeNodeFlags_NoNavFocus = 1 << 27,// Don't claim nav focus when interacting with this item (#8551)
1077	ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1 << 28,// FIXME-WIP: Hard-coded for CollapsingHeader()
1078	ImGuiTreeNodeFlags_UpsideDownArrow = 1 << 29,// FIXME-WIP: Turn Down arrow into an Up arrow, for reversed trees (#6517)
1079	ImGuiTreeNodeFlags_OpenOnMask_ = ImGuiTreeNodeFlags_OpenOnDoubleClick | ImGuiTreeNodeFlags_OpenOnArrow,
1080	ImGuiTreeNodeFlags_DrawLinesMask_ = ImGuiTreeNodeFlags_DrawLinesNone | ImGuiTreeNodeFlags_DrawLinesFull | ImGuiTreeNodeFlags_DrawLinesToNodes,
1081	};
1082
1083	enum ImGuiSeparatorFlags_
1084	{
1085	ImGuiSeparatorFlags_None = 0,
1086	ImGuiSeparatorFlags_Horizontal = 1 << 0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
1087	ImGuiSeparatorFlags_Vertical = 1 << 1,
1088	ImGuiSeparatorFlags_SpanAllColumns = 1 << 2, // Make separator cover all columns of a legacy Columns() set.
1089	};
1090
1091	// Flags for FocusWindow(). This is not called ImGuiFocusFlags to avoid confusion with public-facing ImGuiFocusedFlags.
1092	// FIXME: Once we finishing replacing more uses of GetTopMostPopupModal()+IsWindowWithinBeginStackOf()
1093	// and FindBlockingModal() with this, we may want to change the flag to be opt-out instead of opt-in.
1094	enum ImGuiFocusRequestFlags_
1095	{
1096	ImGuiFocusRequestFlags_None = 0,
1097	ImGuiFocusRequestFlags_RestoreFocusedChild = 1 << 0, // Find last focused child (if any) and focus it instead.
1098	ImGuiFocusRequestFlags_UnlessBelowModal = 1 << 1, // Do not set focus if the window is below a modal.
1099	};
1100
1101	enum ImGuiTextFlags_
1102	{
1103	ImGuiTextFlags_None = 0,
1104	ImGuiTextFlags_NoWidthForLargeClippedText = 1 << 0,
1105	};
1106
1107	enum ImGuiTooltipFlags_
1108	{
1109	ImGuiTooltipFlags_None = 0,
1110	ImGuiTooltipFlags_OverridePrevious = 1 << 1, // Clear/ignore previously submitted tooltip (defaults to append)
1111	};
1112
1113	// FIXME: this is in development, not exposed/functional as a generic feature yet.
1114	// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2
1115	enum ImGuiLayoutType_
1116	{
1117	ImGuiLayoutType_Horizontal = 0,
1118	ImGuiLayoutType_Vertical = 1
1119	};
1120
1121	// Flags for LogBegin() text capturing function
1122	enum ImGuiLogFlags_
1123	{
1124	ImGuiLogFlags_None = 0,
1125
1126	ImGuiLogFlags_OutputTTY = 1 << 0,
1127	ImGuiLogFlags_OutputFile = 1 << 1,
1128	ImGuiLogFlags_OutputBuffer = 1 << 2,
1129	ImGuiLogFlags_OutputClipboard = 1 << 3,
1130	ImGuiLogFlags_OutputMask_ = ImGuiLogFlags_OutputTTY | ImGuiLogFlags_OutputFile | ImGuiLogFlags_OutputBuffer | ImGuiLogFlags_OutputClipboard,
1131	};
1132
1133	// X/Y enums are fixed to 0/1 so they may be used to index ImVec2
1134	enum ImGuiAxis
1135	{
1136	ImGuiAxis_None = -1,
1137	ImGuiAxis_X = 0,
1138	ImGuiAxis_Y = 1
1139	};
1140
1141	enum ImGuiPlotType
1142	{
1143	ImGuiPlotType_Lines,
1144	ImGuiPlotType_Histogram,
1145	};
1146
1147	// Storage data for BeginComboPreview()/EndComboPreview()
1148	struct IMGUI_API ImGuiComboPreviewData
1149	{
1150	ImRect PreviewRect;
1151	ImVec2 BackupCursorPos;
1152	ImVec2 BackupCursorMaxPos;
1153	ImVec2 BackupCursorPosPrevLine;
1154	float BackupPrevLineTextBaseOffset;
1155	ImGuiLayoutType BackupLayout;
1156
1157	ImGuiComboPreviewData() { memset(s: this, c: 0, n: sizeof(*this)); }
1158	};
1159
1160	// Stacked storage data for BeginGroup()/EndGroup()
1161	struct IMGUI_API ImGuiGroupData
1162	{
1163	ImGuiID WindowID;
1164	ImVec2 BackupCursorPos;
1165	ImVec2 BackupCursorMaxPos;
1166	ImVec2 BackupCursorPosPrevLine;
1167	ImVec1 BackupIndent;
1168	ImVec1 BackupGroupOffset;
1169	ImVec2 BackupCurrLineSize;
1170	float BackupCurrLineTextBaseOffset;
1171	ImGuiID BackupActiveIdIsAlive;
1172	bool BackupDeactivatedIdIsAlive;
1173	bool BackupHoveredIdIsAlive;
1174	bool BackupIsSameLine;
1175	bool EmitItem;
1176	};
1177
1178	// Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
1179	struct IMGUI_API ImGuiMenuColumns
1180	{
1181	ImU32 TotalWidth;
1182	ImU32 NextTotalWidth;
1183	ImU16 Spacing;
1184	ImU16 OffsetIcon; // Always zero for now
1185	ImU16 OffsetLabel; // Offsets are locked in Update()
1186	ImU16 OffsetShortcut;
1187	ImU16 OffsetMark;
1188	ImU16 Widths[4]; // Width of: Icon, Label, Shortcut, Mark (accumulators for current frame)
1189
1190	ImGuiMenuColumns() { memset(s: this, c: 0, n: sizeof(*this)); }
1191	void Update(float spacing, bool window_reappearing);
1192	float DeclColumns(float w_icon, float w_label, float w_shortcut, float w_mark);
1193	void CalcNextTotalWidth(bool update_offsets);
1194	};
1195
1196	// Internal temporary state for deactivating InputText() instances.
1197	struct IMGUI_API ImGuiInputTextDeactivatedState
1198	{
1199	ImGuiID ID; // widget id owning the text state (which just got deactivated)
1200	ImVector<char> TextA; // text buffer
1201
1202	ImGuiInputTextDeactivatedState() { memset(s: this, c: 0, n: sizeof(*this)); }
1203	void ClearFreeMemory() { ID = 0; TextA.clear(); }
1204	};
1205
1206	// Forward declare imstb_textedit.h structure + make its main configuration define accessible
1207	#undef IMSTB_TEXTEDIT_STRING
1208	#undef IMSTB_TEXTEDIT_CHARTYPE
1209	#define IMSTB_TEXTEDIT_STRING ImGuiInputTextState
1210	#define IMSTB_TEXTEDIT_CHARTYPE char
1211	#define IMSTB_TEXTEDIT_GETWIDTH_NEWLINE (-1.0f)
1212	#define IMSTB_TEXTEDIT_UNDOSTATECOUNT 99
1213	#define IMSTB_TEXTEDIT_UNDOCHARCOUNT 999
1214	namespace ImStb { struct STB_TexteditState; }
1215	typedef ImStb::STB_TexteditState ImStbTexteditState;
1216
1217	// Internal state of the currently focused/edited text input box
1218	// For a given item ID, access with ImGui::GetInputTextState()
1219	struct IMGUI_API ImGuiInputTextState
1220	{
1221	ImGuiContext* Ctx; // parent UI context (needs to be set explicitly by parent).
1222	ImStbTexteditState* Stb; // State for stb_textedit.h
1223	ImGuiInputTextFlags Flags; // copy of InputText() flags. may be used to check if e.g. ImGuiInputTextFlags_Password is set.
1224	ImGuiID ID; // widget id owning the text state
1225	int TextLen; // UTF-8 length of the string in TextA (in bytes)
1226	const char* TextSrc; // == TextA.Data unless read-only, in which case == buf passed to InputText(). Field only set and valid _inside_ the call InputText() call.
1227	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).
1228	ImVector<char> TextToRevertTo; // value to revert to when pressing Escape = backup of end-user buffer at the time of focus (in UTF-8, unaltered)
1229	ImVector<char> CallbackTextBackup; // temporary storage for callback to support automatic reconcile of undo-stack
1230	int BufCapacity; // end-user buffer capacity (include zero terminator)
1231	ImVec2 Scroll; // horizontal offset (managed manually) + vertical scrolling (pulled from child window's own Scroll.y)
1232	float CursorAnim; // timer for cursor blink, reset on every user action so the cursor reappears immediately
1233	bool CursorFollow; // set when we want scrolling to follow the current cursor position (not always!)
1234	bool SelectedAllMouseLock; // after a double-click to select all, we ignore further mouse drags to update selection
1235	bool Edited; // edited this frame
1236	bool WantReloadUserBuf; // force a reload of user buf so it may be modified externally. may be automatic in future version.
1237	int ReloadSelectionStart;
1238	int ReloadSelectionEnd;
1239
1240	ImGuiInputTextState();
1241	~ImGuiInputTextState();
1242	void ClearText() { TextLen = 0; TextA[0] = 0; CursorClamp(); }
1243	void ClearFreeMemory() { TextA.clear(); TextToRevertTo.clear(); }
1244	void OnKeyPressed(int key); // Cannot be inline because we call in code in stb_textedit.h implementation
1245	void OnCharPressed(unsigned int c);
1246
1247	// Cursor & Selection
1248	void CursorAnimReset();
1249	void CursorClamp();
1250	bool HasSelection() const;
1251	void ClearSelection();
1252	int GetCursorPos() const;
1253	int GetSelectionStart() const;
1254	int GetSelectionEnd() const;
1255	void SelectAll();
1256
1257	// Reload user buf (WIP #2890)
1258	// If you modify underlying user-passed const char* while active you need to call this (InputText V2 may lift this)
1259	// strcpy(my_buf, "hello");
1260	// if (ImGuiInputTextState* state = ImGui::GetInputTextState(id)) // id may be ImGui::GetItemID() is last item
1261	// state->ReloadUserBufAndSelectAll();
1262	void ReloadUserBufAndSelectAll();
1263	void ReloadUserBufAndKeepSelection();
1264	void ReloadUserBufAndMoveToEnd();
1265	};
1266
1267	enum ImGuiWindowRefreshFlags_
1268	{
1269	ImGuiWindowRefreshFlags_None = 0,
1270	ImGuiWindowRefreshFlags_TryToAvoidRefresh = 1 << 0, // [EXPERIMENTAL] Try to keep existing contents, USER MUST NOT HONOR BEGIN() RETURNING FALSE AND NOT APPEND.
1271	ImGuiWindowRefreshFlags_RefreshOnHover = 1 << 1, // [EXPERIMENTAL] Always refresh on hover
1272	ImGuiWindowRefreshFlags_RefreshOnFocus = 1 << 2, // [EXPERIMENTAL] Always refresh on focus
1273	// Refresh policy/frequency, Load Balancing etc.
1274	};
1275
1276	enum ImGuiNextWindowDataFlags_
1277	{
1278	ImGuiNextWindowDataFlags_None = 0,
1279	ImGuiNextWindowDataFlags_HasPos = 1 << 0,
1280	ImGuiNextWindowDataFlags_HasSize = 1 << 1,
1281	ImGuiNextWindowDataFlags_HasContentSize = 1 << 2,
1282	ImGuiNextWindowDataFlags_HasCollapsed = 1 << 3,
1283	ImGuiNextWindowDataFlags_HasSizeConstraint = 1 << 4,
1284	ImGuiNextWindowDataFlags_HasFocus = 1 << 5,
1285	ImGuiNextWindowDataFlags_HasBgAlpha = 1 << 6,
1286	ImGuiNextWindowDataFlags_HasScroll = 1 << 7,
1287	ImGuiNextWindowDataFlags_HasWindowFlags = 1 << 8,
1288	ImGuiNextWindowDataFlags_HasChildFlags = 1 << 9,
1289	ImGuiNextWindowDataFlags_HasRefreshPolicy = 1 << 10,
1290	ImGuiNextWindowDataFlags_HasViewport = 1 << 11,
1291	ImGuiNextWindowDataFlags_HasDock = 1 << 12,
1292	ImGuiNextWindowDataFlags_HasWindowClass = 1 << 13,
1293	};
1294
1295	// Storage for SetNexWindow** functions
1296	struct ImGuiNextWindowData
1297	{
1298	ImGuiNextWindowDataFlags HasFlags;
1299
1300	// Members below are NOT cleared. Always rely on HasFlags.
1301	ImGuiCond PosCond;
1302	ImGuiCond SizeCond;
1303	ImGuiCond CollapsedCond;
1304	ImGuiCond DockCond;
1305	ImVec2 PosVal;
1306	ImVec2 PosPivotVal;
1307	ImVec2 SizeVal;
1308	ImVec2 ContentSizeVal;
1309	ImVec2 ScrollVal;
1310	ImGuiWindowFlags WindowFlags; // Only honored by BeginTable()
1311	ImGuiChildFlags ChildFlags;
1312	bool PosUndock;
1313	bool CollapsedVal;
1314	ImRect SizeConstraintRect;
1315	ImGuiSizeCallback SizeCallback;
1316	void* SizeCallbackUserData;
1317	float BgAlphaVal; // Override background alpha
1318	ImGuiID ViewportId;
1319	ImGuiID DockId;
1320	ImGuiWindowClass WindowClass;
1321	ImVec2 MenuBarOffsetMinVal; // (Always on) This is not exposed publicly, so we don't clear it and it doesn't have a corresponding flag (could we? for consistency?)
1322	ImGuiWindowRefreshFlags RefreshFlagsVal;
1323
1324	ImGuiNextWindowData() { memset(s: this, c: 0, n: sizeof(*this)); }
1325	inline void ClearFlags() { HasFlags = ImGuiNextWindowDataFlags_None; }
1326	};
1327
1328	enum ImGuiNextItemDataFlags_
1329	{
1330	ImGuiNextItemDataFlags_None = 0,
1331	ImGuiNextItemDataFlags_HasWidth = 1 << 0,
1332	ImGuiNextItemDataFlags_HasOpen = 1 << 1,
1333	ImGuiNextItemDataFlags_HasShortcut = 1 << 2,
1334	ImGuiNextItemDataFlags_HasRefVal = 1 << 3,
1335	ImGuiNextItemDataFlags_HasStorageID = 1 << 4,
1336	};
1337
1338	struct ImGuiNextItemData
1339	{
1340	ImGuiNextItemDataFlags HasFlags; // Called HasFlags instead of Flags to avoid mistaking this
1341	ImGuiItemFlags ItemFlags; // Currently only tested/used for ImGuiItemFlags_AllowOverlap and ImGuiItemFlags_HasSelectionUserData.
1342
1343	// Members below are NOT cleared by ItemAdd() meaning they are still valid during e.g. NavProcessItem(). Always rely on HasFlags.
1344	ImGuiID FocusScopeId; // Set by SetNextItemSelectionUserData()
1345	ImGuiSelectionUserData SelectionUserData; // Set by SetNextItemSelectionUserData() (note that NULL/0 is a valid value, we use -1 == ImGuiSelectionUserData_Invalid to mark invalid values)
1346	float Width; // Set by SetNextItemWidth()
1347	ImGuiKeyChord Shortcut; // Set by SetNextItemShortcut()
1348	ImGuiInputFlags ShortcutFlags; // Set by SetNextItemShortcut()
1349	bool OpenVal; // Set by SetNextItemOpen()
1350	ImU8 OpenCond; // Set by SetNextItemOpen()
1351	ImGuiDataTypeStorage RefVal; // Not exposed yet, for ImGuiInputTextFlags_ParseEmptyAsRefVal
1352	ImGuiID StorageId; // Set by SetNextItemStorageID()
1353
1354	ImGuiNextItemData() { memset(s: this, c: 0, n: sizeof(*this)); SelectionUserData = -1; }
1355	inline void ClearFlags() { HasFlags = ImGuiNextItemDataFlags_None; ItemFlags = ImGuiItemFlags_None; } // Also cleared manually by ItemAdd()!
1356	};
1357
1358	// Status storage for the last submitted item
1359	struct ImGuiLastItemData
1360	{
1361	ImGuiID ID;
1362	ImGuiItemFlags ItemFlags; // See ImGuiItemFlags_ (called 'InFlags' before v1.91.4).
1363	ImGuiItemStatusFlags StatusFlags; // See ImGuiItemStatusFlags_
1364	ImRect Rect; // Full rectangle
1365	ImRect NavRect; // Navigation scoring rectangle (not displayed)
1366	// Rarely used fields are not explicitly cleared, only valid when the corresponding ImGuiItemStatusFlags are set.
1367	ImRect DisplayRect; // Display rectangle. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasDisplayRect) is set.
1368	ImRect ClipRect; // Clip rectangle at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasClipRect) is set..
1369	ImGuiKeyChord Shortcut; // Shortcut at the time of submitting item. ONLY VALID IF (StatusFlags & ImGuiItemStatusFlags_HasShortcut) is set..
1370
1371	ImGuiLastItemData() { memset(s: this, c: 0, n: sizeof(*this)); }
1372	};
1373
1374	// Store data emitted by TreeNode() for usage by TreePop()
1375	// - To implement ImGuiTreeNodeFlags_NavLeftJumpsToParent: store the minimum amount of data
1376	// which we can't infer in TreePop(), to perform the equivalent of NavApplyItemToResult().
1377	// Only stored when the node is a potential candidate for landing on a Left arrow jump.
1378	struct ImGuiTreeNodeStackData
1379	{
1380	ImGuiID ID;
1381	ImGuiTreeNodeFlags TreeFlags;
1382	ImGuiItemFlags ItemFlags; // Used for nav landing
1383	ImRect NavRect; // Used for nav landing
1384	float DrawLinesX1;
1385	float DrawLinesToNodesY2;
1386	ImGuiTableColumnIdx DrawLinesTableColumn;
1387	};
1388
1389	// sizeof() = 20
1390	struct IMGUI_API ImGuiErrorRecoveryState
1391	{
1392	short SizeOfWindowStack;
1393	short SizeOfIDStack;
1394	short SizeOfTreeStack;
1395	short SizeOfColorStack;
1396	short SizeOfStyleVarStack;
1397	short SizeOfFontStack;
1398	short SizeOfFocusScopeStack;
1399	short SizeOfGroupStack;
1400	short SizeOfItemFlagsStack;
1401	short SizeOfBeginPopupStack;
1402	short SizeOfDisabledStack;
1403
1404	ImGuiErrorRecoveryState() { memset(s: this, c: 0, n: sizeof(*this)); }
1405	};
1406
1407	// Data saved for each window pushed into the stack
1408	struct ImGuiWindowStackData
1409	{
1410	ImGuiWindow* Window;
1411	ImGuiLastItemData ParentLastItemDataBackup;
1412	ImGuiErrorRecoveryState StackSizesInBegin; // Store size of various stacks for asserting
1413	bool DisabledOverrideReenable; // Non-child window override disabled flag
1414	float DisabledOverrideReenableAlphaBackup;
1415	};
1416
1417	struct ImGuiShrinkWidthItem
1418	{
1419	int Index;
1420	float Width;
1421	float InitialWidth;
1422	};
1423
1424	struct ImGuiPtrOrIndex
1425	{
1426	void* Ptr; // Either field can be set, not both. e.g. Dock node tab bars are loose while BeginTabBar() ones are in a pool.
1427	int Index; // Usually index in a main pool.
1428
1429	ImGuiPtrOrIndex(void* ptr) { Ptr = ptr; Index = -1; }
1430	ImGuiPtrOrIndex(int index) { Ptr = NULL; Index = index; }
1431	};
1432
1433	// Data used by IsItemDeactivated()/IsItemDeactivatedAfterEdit() functions
1434	struct ImGuiDeactivatedItemData
1435	{
1436	ImGuiID ID;
1437	int ElapseFrame;
1438	bool HasBeenEditedBefore;
1439	bool IsAlive;
1440	};
1441
1442	//-----------------------------------------------------------------------------
1443	// [SECTION] Popup support
1444	//-----------------------------------------------------------------------------
1445
1446	enum ImGuiPopupPositionPolicy
1447	{
1448	ImGuiPopupPositionPolicy_Default,
1449	ImGuiPopupPositionPolicy_ComboBox,
1450	ImGuiPopupPositionPolicy_Tooltip,
1451	};
1452
1453	// Storage for popup stacks (g.OpenPopupStack and g.BeginPopupStack)
1454	struct ImGuiPopupData
1455	{
1456	ImGuiID PopupId; // Set on OpenPopup()
1457	ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
1458	ImGuiWindow* RestoreNavWindow;// Set on OpenPopup(), a NavWindow that will be restored on popup close
1459	int ParentNavLayer; // Resolved on BeginPopup(). Actually a ImGuiNavLayer type (declared down below), initialized to -1 which is not part of an enum, but serves well-enough as "not any of layers" value
1460	int OpenFrameCount; // Set on OpenPopup()
1461	ImGuiID OpenParentId; // Set on OpenPopup(), we need this to differentiate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
1462	ImVec2 OpenPopupPos; // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
1463	ImVec2 OpenMousePos; // Set on OpenPopup(), copy of mouse position at the time of opening popup
1464
1465	ImGuiPopupData() { memset(s: this, c: 0, n: sizeof(*this)); ParentNavLayer = OpenFrameCount = -1; }
1466	};
1467
1468	//-----------------------------------------------------------------------------
1469	// [SECTION] Inputs support
1470	//-----------------------------------------------------------------------------
1471
1472	// Bit array for named keys
1473	typedef ImBitArray<ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN> ImBitArrayForNamedKeys;
1474
1475	// [Internal] Key ranges
1476	#define ImGuiKey_LegacyNativeKey_BEGIN 0
1477	#define ImGuiKey_LegacyNativeKey_END 512
1478	#define ImGuiKey_Keyboard_BEGIN (ImGuiKey_NamedKey_BEGIN)
1479	#define ImGuiKey_Keyboard_END (ImGuiKey_GamepadStart)
1480	#define ImGuiKey_Gamepad_BEGIN (ImGuiKey_GamepadStart)
1481	#define ImGuiKey_Gamepad_END (ImGuiKey_GamepadRStickDown + 1)
1482	#define ImGuiKey_Mouse_BEGIN (ImGuiKey_MouseLeft)
1483	#define ImGuiKey_Mouse_END (ImGuiKey_MouseWheelY + 1)
1484	#define ImGuiKey_Aliases_BEGIN (ImGuiKey_Mouse_BEGIN)
1485	#define ImGuiKey_Aliases_END (ImGuiKey_Mouse_END)
1486
1487	// [Internal] Named shortcuts for Navigation
1488	#define ImGuiKey_NavKeyboardTweakSlow ImGuiMod_Ctrl
1489	#define ImGuiKey_NavKeyboardTweakFast ImGuiMod_Shift
1490	#define ImGuiKey_NavGamepadTweakSlow ImGuiKey_GamepadL1
1491	#define ImGuiKey_NavGamepadTweakFast ImGuiKey_GamepadR1
1492	#define ImGuiKey_NavGamepadActivate (g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceRight : ImGuiKey_GamepadFaceDown)
1493	#define ImGuiKey_NavGamepadCancel (g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceDown : ImGuiKey_GamepadFaceRight)
1494	#define ImGuiKey_NavGamepadMenu ImGuiKey_GamepadFaceLeft
1495	#define ImGuiKey_NavGamepadInput ImGuiKey_GamepadFaceUp
1496
1497	enum ImGuiInputEventType
1498	{
1499	ImGuiInputEventType_None = 0,
1500	ImGuiInputEventType_MousePos,
1501	ImGuiInputEventType_MouseWheel,
1502	ImGuiInputEventType_MouseButton,
1503	ImGuiInputEventType_MouseViewport,
1504	ImGuiInputEventType_Key,
1505	ImGuiInputEventType_Text,
1506	ImGuiInputEventType_Focus,
1507	ImGuiInputEventType_COUNT
1508	};
1509
1510	enum ImGuiInputSource : int
1511	{
1512	ImGuiInputSource_None = 0,
1513	ImGuiInputSource_Mouse, // Note: may be Mouse or TouchScreen or Pen. See io.MouseSource to distinguish them.
1514	ImGuiInputSource_Keyboard,
1515	ImGuiInputSource_Gamepad,
1516	ImGuiInputSource_COUNT
1517	};
1518
1519	// FIXME: Structures in the union below need to be declared as anonymous unions appears to be an extension?
1520	// Using ImVec2() would fail on Clang 'union member 'MousePos' has a non-trivial default constructor'
1521	struct ImGuiInputEventMousePos { float PosX, PosY; ImGuiMouseSource MouseSource; };
1522	struct ImGuiInputEventMouseWheel { float WheelX, WheelY; ImGuiMouseSource MouseSource; };
1523	struct ImGuiInputEventMouseButton { int Button; bool Down; ImGuiMouseSource MouseSource; };
1524	struct ImGuiInputEventMouseViewport { ImGuiID HoveredViewportID; };
1525	struct ImGuiInputEventKey { ImGuiKey Key; bool Down; float AnalogValue; };
1526	struct ImGuiInputEventText { unsigned int Char; };
1527	struct ImGuiInputEventAppFocused { bool Focused; };
1528
1529	struct ImGuiInputEvent
1530	{
1531	ImGuiInputEventType Type;
1532	ImGuiInputSource Source;
1533	ImU32 EventId; // Unique, sequential increasing integer to identify an event (if you need to correlate them to other data).
1534	union
1535	{
1536	ImGuiInputEventMousePos MousePos; // if Type == ImGuiInputEventType_MousePos
1537	ImGuiInputEventMouseWheel MouseWheel; // if Type == ImGuiInputEventType_MouseWheel
1538	ImGuiInputEventMouseButton MouseButton; // if Type == ImGuiInputEventType_MouseButton
1539	ImGuiInputEventMouseViewport MouseViewport; // if Type == ImGuiInputEventType_MouseViewport
1540	ImGuiInputEventKey Key; // if Type == ImGuiInputEventType_Key
1541	ImGuiInputEventText Text; // if Type == ImGuiInputEventType_Text
1542	ImGuiInputEventAppFocused AppFocused; // if Type == ImGuiInputEventType_Focus
1543	};
1544	bool AddedByTestEngine;
1545
1546	ImGuiInputEvent() { memset(s: this, c: 0, n: sizeof(*this)); }
1547	};
1548
1549	// Input function taking an 'ImGuiID owner_id' argument defaults to (ImGuiKeyOwner_Any == 0) aka don't test ownership, which matches legacy behavior.
1550	#define ImGuiKeyOwner_Any ((ImGuiID)0) // Accept key that have an owner, UNLESS a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease.
1551	#define ImGuiKeyOwner_NoOwner ((ImGuiID)-1) // Require key to have no owner.
1552	//#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.
1553
1554	typedef ImS16 ImGuiKeyRoutingIndex;
1555
1556	// Routing table entry (sizeof() == 16 bytes)
1557	struct ImGuiKeyRoutingData
1558	{
1559	ImGuiKeyRoutingIndex NextEntryIndex;
1560	ImU16 Mods; // Technically we'd only need 4-bits but for simplify we store ImGuiMod_ values which need 16-bits.
1561	ImU8 RoutingCurrScore; // [DEBUG] For debug display
1562	ImU8 RoutingNextScore; // Lower is better (0: perfect score)
1563	ImGuiID RoutingCurr;
1564	ImGuiID RoutingNext;
1565
1566	ImGuiKeyRoutingData() { NextEntryIndex = -1; Mods = 0; RoutingCurrScore = RoutingNextScore = 255; RoutingCurr = RoutingNext = ImGuiKeyOwner_NoOwner; }
1567	};
1568
1569	// Routing table: maintain a desired owner for each possible key-chord (key + mods), and setup owner in NewFrame() when mods are matching.
1570	// Stored in main context (1 instance)
1571	struct ImGuiKeyRoutingTable
1572	{
1573	ImGuiKeyRoutingIndex Index[ImGuiKey_NamedKey_COUNT]; // Index of first entry in Entries[]
1574	ImVector<ImGuiKeyRoutingData> Entries;
1575	ImVector<ImGuiKeyRoutingData> EntriesNext; // Double-buffer to avoid reallocation (could use a shared buffer)
1576
1577	ImGuiKeyRoutingTable() { Clear(); }
1578	void Clear() { for (int n = 0; n < IM_ARRAYSIZE(Index); n++) Index[n] = -1; Entries.clear(); EntriesNext.clear(); }
1579	};
1580
1581	// This extends ImGuiKeyData but only for named keys (legacy keys don't support the new features)
1582	// Stored in main context (1 per named key). In the future it might be merged into ImGuiKeyData.
1583	struct ImGuiKeyOwnerData
1584	{
1585	ImGuiID OwnerCurr;
1586	ImGuiID OwnerNext;
1587	bool LockThisFrame; // Reading this key requires explicit owner id (until end of frame). Set by ImGuiInputFlags_LockThisFrame.
1588	bool LockUntilRelease; // Reading this key requires explicit owner id (until key is released). Set by ImGuiInputFlags_LockUntilRelease. When this is true LockThisFrame is always true as well.
1589
1590	ImGuiKeyOwnerData() { OwnerCurr = OwnerNext = ImGuiKeyOwner_NoOwner; LockThisFrame = LockUntilRelease = false; }
1591	};
1592
1593	// Extend ImGuiInputFlags_
1594	// Flags for extended versions of IsKeyPressed(), IsMouseClicked(), Shortcut(), SetKeyOwner(), SetItemKeyOwner()
1595	// Don't mistake with ImGuiInputTextFlags! (which is for ImGui::InputText() function)
1596	enum ImGuiInputFlagsPrivate_
1597	{
1598	// Flags for IsKeyPressed(), IsKeyChordPressed(), IsMouseClicked(), Shortcut()
1599	// - Repeat mode: Repeat rate selection
1600	ImGuiInputFlags_RepeatRateDefault = 1 << 1, // Repeat rate: Regular (default)
1601	ImGuiInputFlags_RepeatRateNavMove = 1 << 2, // Repeat rate: Fast
1602	ImGuiInputFlags_RepeatRateNavTweak = 1 << 3, // Repeat rate: Faster
1603	// - Repeat mode: Specify when repeating key pressed can be interrupted.
1604	// - In theory ImGuiInputFlags_RepeatUntilOtherKeyPress may be a desirable default, but it would break too many behavior so everything is opt-in.
1605	ImGuiInputFlags_RepeatUntilRelease = 1 << 4, // Stop repeating when released (default for all functions except Shortcut). This only exists to allow overriding Shortcut() default behavior.
1606	ImGuiInputFlags_RepeatUntilKeyModsChange = 1 << 5, // Stop repeating when released OR if keyboard mods are changed (default for Shortcut)
1607	ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone = 1 << 6, // Stop repeating when released OR if keyboard mods are leaving the None state. Allows going from Mod+Key to Key by releasing Mod.
1608	ImGuiInputFlags_RepeatUntilOtherKeyPress = 1 << 7, // Stop repeating when released OR if any other keyboard key is pressed during the repeat
1609
1610	// Flags for SetKeyOwner(), SetItemKeyOwner()
1611	// - 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.
1612	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.
1613	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.
1614
1615	// - Condition for SetItemKeyOwner()
1616	ImGuiInputFlags_CondHovered = 1 << 22, // Only set if item is hovered (default to both)
1617	ImGuiInputFlags_CondActive = 1 << 23, // Only set if item is active (default to both)
1618	ImGuiInputFlags_CondDefault_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive,
1619
1620	// [Internal] Mask of which function support which flags
1621	ImGuiInputFlags_RepeatRateMask_ = ImGuiInputFlags_RepeatRateDefault | ImGuiInputFlags_RepeatRateNavMove | ImGuiInputFlags_RepeatRateNavTweak,
1622	ImGuiInputFlags_RepeatUntilMask_ = ImGuiInputFlags_RepeatUntilRelease | ImGuiInputFlags_RepeatUntilKeyModsChange | ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone | ImGuiInputFlags_RepeatUntilOtherKeyPress,
1623	ImGuiInputFlags_RepeatMask_ = ImGuiInputFlags_Repeat | ImGuiInputFlags_RepeatRateMask_ | ImGuiInputFlags_RepeatUntilMask_,
1624	ImGuiInputFlags_CondMask_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive,
1625	ImGuiInputFlags_RouteTypeMask_ = ImGuiInputFlags_RouteActive | ImGuiInputFlags_RouteFocused | ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteAlways,
1626	ImGuiInputFlags_RouteOptionsMask_ = ImGuiInputFlags_RouteOverFocused | ImGuiInputFlags_RouteOverActive | ImGuiInputFlags_RouteUnlessBgFocused | ImGuiInputFlags_RouteFromRootWindow,
1627	ImGuiInputFlags_SupportedByIsKeyPressed = ImGuiInputFlags_RepeatMask_,
1628	ImGuiInputFlags_SupportedByIsMouseClicked = ImGuiInputFlags_Repeat,
1629	ImGuiInputFlags_SupportedByShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_,
1630	ImGuiInputFlags_SupportedBySetNextItemShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_ | ImGuiInputFlags_Tooltip,
1631	ImGuiInputFlags_SupportedBySetKeyOwner = ImGuiInputFlags_LockThisFrame | ImGuiInputFlags_LockUntilRelease,
1632	ImGuiInputFlags_SupportedBySetItemKeyOwner = ImGuiInputFlags_SupportedBySetKeyOwner | ImGuiInputFlags_CondMask_,
1633	};
1634
1635	//-----------------------------------------------------------------------------
1636	// [SECTION] Clipper support
1637	//-----------------------------------------------------------------------------
1638
1639	// Note that Max is exclusive, so perhaps should be using a Begin/End convention.
1640	struct ImGuiListClipperRange
1641	{
1642	int Min;
1643	int Max;
1644	bool PosToIndexConvert; // Begin/End are absolute position (will be converted to indices later)
1645	ImS8 PosToIndexOffsetMin; // Add to Min after converting to indices
1646	ImS8 PosToIndexOffsetMax; // Add to Min after converting to indices
1647
1648	static ImGuiListClipperRange FromIndices(int min, int max) { ImGuiListClipperRange r = { .Min: min, .Max: max, .PosToIndexConvert: false, .PosToIndexOffsetMin: 0, .PosToIndexOffsetMax: 0 }; return r; }
1649	static ImGuiListClipperRange FromPositions(float y1, float y2, int off_min, int off_max) { ImGuiListClipperRange r = { .Min: (int)y1, .Max: (int)y2, .PosToIndexConvert: true, .PosToIndexOffsetMin: (ImS8)off_min, .PosToIndexOffsetMax: (ImS8)off_max }; return r; }
1650	};
1651
1652	// Temporary clipper data, buffers shared/reused between instances
1653	struct ImGuiListClipperData
1654	{
1655	ImGuiListClipper* ListClipper;
1656	float LossynessOffset;
1657	int StepNo;
1658	int ItemsFrozen;
1659	ImVector<ImGuiListClipperRange> Ranges;
1660
1661	ImGuiListClipperData() { memset(s: this, c: 0, n: sizeof(*this)); }
1662	void Reset(ImGuiListClipper* clipper) { ListClipper = clipper; StepNo = ItemsFrozen = 0; Ranges.resize(new_size: 0); }
1663	};
1664
1665	//-----------------------------------------------------------------------------
1666	// [SECTION] Navigation support
1667	//-----------------------------------------------------------------------------
1668
1669	enum ImGuiActivateFlags_
1670	{
1671	ImGuiActivateFlags_None = 0,
1672	ImGuiActivateFlags_PreferInput = 1 << 0, // Favor activation that requires keyboard text input (e.g. for Slider/Drag). Default for Enter key.
1673	ImGuiActivateFlags_PreferTweak = 1 << 1, // Favor activation for tweaking with arrows or gamepad (e.g. for Slider/Drag). Default for Space key and if keyboard is not used.
1674	ImGuiActivateFlags_TryToPreserveState = 1 << 2, // Request widget to preserve state if it can (e.g. InputText will try to preserve cursor/selection)
1675	ImGuiActivateFlags_FromTabbing = 1 << 3, // Activation requested by a tabbing request
1676	ImGuiActivateFlags_FromShortcut = 1 << 4, // Activation requested by an item shortcut via SetNextItemShortcut() function.
1677	};
1678
1679	// Early work-in-progress API for ScrollToItem()
1680	enum ImGuiScrollFlags_
1681	{
1682	ImGuiScrollFlags_None = 0,
1683	ImGuiScrollFlags_KeepVisibleEdgeX = 1 << 0, // If item is not visible: scroll as little as possible on X axis to bring item back into view [default for X axis]
1684	ImGuiScrollFlags_KeepVisibleEdgeY = 1 << 1, // If item is not visible: scroll as little as possible on Y axis to bring item back into view [default for Y axis for windows that are already visible]
1685	ImGuiScrollFlags_KeepVisibleCenterX = 1 << 2, // If item is not visible: scroll to make the item centered on X axis [rarely used]
1686	ImGuiScrollFlags_KeepVisibleCenterY = 1 << 3, // If item is not visible: scroll to make the item centered on Y axis
1687	ImGuiScrollFlags_AlwaysCenterX = 1 << 4, // Always center the result item on X axis [rarely used]
1688	ImGuiScrollFlags_AlwaysCenterY = 1 << 5, // Always center the result item on Y axis [default for Y axis for appearing window)
1689	ImGuiScrollFlags_NoScrollParent = 1 << 6, // Disable forwarding scrolling to parent window if required to keep item/rect visible (only scroll window the function was applied to).
1690	ImGuiScrollFlags_MaskX_ = ImGuiScrollFlags_KeepVisibleEdgeX | ImGuiScrollFlags_KeepVisibleCenterX | ImGuiScrollFlags_AlwaysCenterX,
1691	ImGuiScrollFlags_MaskY_ = ImGuiScrollFlags_KeepVisibleEdgeY | ImGuiScrollFlags_KeepVisibleCenterY | ImGuiScrollFlags_AlwaysCenterY,
1692	};
1693
1694	enum ImGuiNavRenderCursorFlags_
1695	{
1696	ImGuiNavRenderCursorFlags_None = 0,
1697	ImGuiNavRenderCursorFlags_Compact = 1 << 1, // Compact highlight, no padding/distance from focused item
1698	ImGuiNavRenderCursorFlags_AlwaysDraw = 1 << 2, // Draw rectangular highlight if (g.NavId == id) even when g.NavCursorVisible == false, aka even when using the mouse.
1699	ImGuiNavRenderCursorFlags_NoRounding = 1 << 3,
1700	#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
1701	ImGuiNavHighlightFlags_None = ImGuiNavRenderCursorFlags_None, // Renamed in 1.91.4
1702	ImGuiNavHighlightFlags_Compact = ImGuiNavRenderCursorFlags_Compact, // Renamed in 1.91.4
1703	ImGuiNavHighlightFlags_AlwaysDraw = ImGuiNavRenderCursorFlags_AlwaysDraw, // Renamed in 1.91.4
1704	ImGuiNavHighlightFlags_NoRounding = ImGuiNavRenderCursorFlags_NoRounding, // Renamed in 1.91.4
1705	//ImGuiNavHighlightFlags_TypeThin = ImGuiNavRenderCursorFlags_Compact, // Renamed in 1.90.2
1706	#endif
1707	};
1708
1709	enum ImGuiNavMoveFlags_
1710	{
1711	ImGuiNavMoveFlags_None = 0,
1712	ImGuiNavMoveFlags_LoopX = 1 << 0, // On failed request, restart from opposite side
1713	ImGuiNavMoveFlags_LoopY = 1 << 1,
1714	ImGuiNavMoveFlags_WrapX = 1 << 2, // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
1715	ImGuiNavMoveFlags_WrapY = 1 << 3, // This is not super useful but provided for completeness
1716	ImGuiNavMoveFlags_WrapMask_ = ImGuiNavMoveFlags_LoopX | ImGuiNavMoveFlags_LoopY | ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_WrapY,
1717	ImGuiNavMoveFlags_AllowCurrentNavId = 1 << 4, // Allow scoring and considering the current NavId as a move target candidate. This is used when the move source is offset (e.g. pressing PageDown actually needs to send a Up move request, if we are pressing PageDown from the bottom-most item we need to stay in place)
1718	ImGuiNavMoveFlags_AlsoScoreVisibleSet = 1 << 5, // Store alternate result in NavMoveResultLocalVisible that only comprise elements that are already fully visible (used by PageUp/PageDown)
1719	ImGuiNavMoveFlags_ScrollToEdgeY = 1 << 6, // Force scrolling to min/max (used by Home/End) // FIXME-NAV: Aim to remove or reword, probably unnecessary
1720	ImGuiNavMoveFlags_Forwarded = 1 << 7,
1721	ImGuiNavMoveFlags_DebugNoResult = 1 << 8, // Dummy scoring for debug purpose, don't apply result
1722	ImGuiNavMoveFlags_FocusApi = 1 << 9, // Requests from focus API can land/focus/activate items even if they are marked with _NoTabStop (see NavProcessItemForTabbingRequest() for details)
1723	ImGuiNavMoveFlags_IsTabbing = 1 << 10, // == Focus + Activate if item is Inputable + DontChangeNavHighlight
1724	ImGuiNavMoveFlags_IsPageMove = 1 << 11, // Identify a PageDown/PageUp request.
1725	ImGuiNavMoveFlags_Activate = 1 << 12, // Activate/select target item.
1726	ImGuiNavMoveFlags_NoSelect = 1 << 13, // Don't trigger selection by not setting g.NavJustMovedTo
1727	ImGuiNavMoveFlags_NoSetNavCursorVisible = 1 << 14, // Do not alter the nav cursor visible state
1728	ImGuiNavMoveFlags_NoClearActiveId = 1 << 15, // (Experimental) Do not clear active id when applying move result
1729	};
1730
1731	enum ImGuiNavLayer
1732	{
1733	ImGuiNavLayer_Main = 0, // Main scrolling layer
1734	ImGuiNavLayer_Menu = 1, // Menu layer (access with Alt)
1735	ImGuiNavLayer_COUNT
1736	};
1737
1738	// Storage for navigation query/results
1739	struct ImGuiNavItemData
1740	{
1741	ImGuiWindow* Window; // Init,Move // Best candidate window (result->ItemWindow->RootWindowForNav == request->Window)
1742	ImGuiID ID; // Init,Move // Best candidate item ID
1743	ImGuiID FocusScopeId; // Init,Move // Best candidate focus scope ID
1744	ImRect RectRel; // Init,Move // Best candidate bounding box in window relative space
1745	ImGuiItemFlags ItemFlags; // ????,Move // Best candidate item flags
1746	float DistBox; // Move // Best candidate box distance to current NavId
1747	float DistCenter; // Move // Best candidate center distance to current NavId
1748	float DistAxial; // Move // Best candidate axial distance to current NavId
1749	ImGuiSelectionUserData SelectionUserData;//I+Mov // Best candidate SetNextItemSelectionUserData() value. Valid if (ItemFlags & ImGuiItemFlags_HasSelectionUserData)
1750
1751	ImGuiNavItemData() { Clear(); }
1752	void Clear() { Window = NULL; ID = FocusScopeId = 0; ItemFlags = 0; SelectionUserData = -1; DistBox = DistCenter = DistAxial = FLT_MAX; }
1753	};
1754
1755	// Storage for PushFocusScope(), g.FocusScopeStack[], g.NavFocusRoute[]
1756	struct ImGuiFocusScopeData
1757	{
1758	ImGuiID ID;
1759	ImGuiID WindowID;
1760	};
1761
1762	//-----------------------------------------------------------------------------
1763	// [SECTION] Typing-select support
1764	//-----------------------------------------------------------------------------
1765
1766	// Flags for GetTypingSelectRequest()
1767	enum ImGuiTypingSelectFlags_
1768	{
1769	ImGuiTypingSelectFlags_None = 0,
1770	ImGuiTypingSelectFlags_AllowBackspace = 1 << 0, // Backspace to delete character inputs. If using: ensure GetTypingSelectRequest() is not called more than once per frame (filter by e.g. focus state)
1771	ImGuiTypingSelectFlags_AllowSingleCharMode = 1 << 1, // Allow "single char" search mode which is activated when pressing the same character multiple times.
1772	};
1773
1774	// Returned by GetTypingSelectRequest(), designed to eventually be public.
1775	struct IMGUI_API ImGuiTypingSelectRequest
1776	{
1777	ImGuiTypingSelectFlags Flags; // Flags passed to GetTypingSelectRequest()
1778	int SearchBufferLen;
1779	const char* SearchBuffer; // Search buffer contents (use full string. unless SingleCharMode is set, in which case use SingleCharSize).
1780	bool SelectRequest; // Set when buffer was modified this frame, requesting a selection.
1781	bool SingleCharMode; // Notify when buffer contains same character repeated, to implement special mode. In this situation it preferred to not display any on-screen search indication.
1782	ImS8 SingleCharSize; // Length in bytes of first letter codepoint (1 for ascii, 2-4 for UTF-8). If (SearchBufferLen==RepeatCharSize) only 1 letter has been input.
1783	};
1784
1785	// Storage for GetTypingSelectRequest()
1786	struct IMGUI_API ImGuiTypingSelectState
1787	{
1788	ImGuiTypingSelectRequest Request; // User-facing data
1789	char SearchBuffer[64]; // Search buffer: no need to make dynamic as this search is very transient.
1790	ImGuiID FocusScope;
1791	int LastRequestFrame = 0;
1792	float LastRequestTime = 0.0f;
1793	bool SingleCharModeLock = false; // After a certain single char repeat count we lock into SingleCharMode. Two benefits: 1) buffer never fill, 2) we can provide an immediate SingleChar mode without timer elapsing.
1794
1795	ImGuiTypingSelectState() { memset(s: this, c: 0, n: sizeof(*this)); }
1796	void Clear() { SearchBuffer[0] = 0; SingleCharModeLock = false; } // We preserve remaining data for easier debugging
1797	};
1798
1799	//-----------------------------------------------------------------------------
1800	// [SECTION] Columns support
1801	//-----------------------------------------------------------------------------
1802
1803	// Flags for internal's BeginColumns(). This is an obsolete API. Prefer using BeginTable() nowadays!
1804	enum ImGuiOldColumnFlags_
1805	{
1806	ImGuiOldColumnFlags_None = 0,
1807	ImGuiOldColumnFlags_NoBorder = 1 << 0, // Disable column dividers
1808	ImGuiOldColumnFlags_NoResize = 1 << 1, // Disable resizing columns when clicking on the dividers
1809	ImGuiOldColumnFlags_NoPreserveWidths = 1 << 2, // Disable column width preservation when adjusting columns
1810	ImGuiOldColumnFlags_NoForceWithinWindow = 1 << 3, // Disable forcing columns to fit within window
1811	ImGuiOldColumnFlags_GrowParentContentsSize = 1 << 4, // Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
1812
1813	// Obsolete names (will be removed)
1814	#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
1815	//ImGuiColumnsFlags_None = ImGuiOldColumnFlags_None,
1816	//ImGuiColumnsFlags_NoBorder = ImGuiOldColumnFlags_NoBorder,
1817	//ImGuiColumnsFlags_NoResize = ImGuiOldColumnFlags_NoResize,
1818	//ImGuiColumnsFlags_NoPreserveWidths = ImGuiOldColumnFlags_NoPreserveWidths,
1819	//ImGuiColumnsFlags_NoForceWithinWindow = ImGuiOldColumnFlags_NoForceWithinWindow,
1820	//ImGuiColumnsFlags_GrowParentContentsSize = ImGuiOldColumnFlags_GrowParentContentsSize,
1821	#endif
1822	};
1823
1824	struct ImGuiOldColumnData
1825	{
1826	float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
1827	float OffsetNormBeforeResize;
1828	ImGuiOldColumnFlags Flags; // Not exposed
1829	ImRect ClipRect;
1830
1831	ImGuiOldColumnData() { memset(s: this, c: 0, n: sizeof(*this)); }
1832	};
1833
1834	struct ImGuiOldColumns
1835	{
1836	ImGuiID ID;
1837	ImGuiOldColumnFlags Flags;
1838	bool IsFirstFrame;
1839	bool IsBeingResized;
1840	int Current;
1841	int Count;
1842	float OffMinX, OffMaxX; // Offsets from HostWorkRect.Min.x
1843	float LineMinY, LineMaxY;
1844	float HostCursorPosY; // Backup of CursorPos at the time of BeginColumns()
1845	float HostCursorMaxPosX; // Backup of CursorMaxPos at the time of BeginColumns()
1846	ImRect HostInitialClipRect; // Backup of ClipRect at the time of BeginColumns()
1847	ImRect HostBackupClipRect; // Backup of ClipRect during PushColumnsBackground()/PopColumnsBackground()
1848	ImRect HostBackupParentWorkRect;//Backup of WorkRect at the time of BeginColumns()
1849	ImVector<ImGuiOldColumnData> Columns;
1850	ImDrawListSplitter Splitter;
1851
1852	ImGuiOldColumns() { memset(s: this, c: 0, n: sizeof(*this)); }
1853	};
1854
1855	//-----------------------------------------------------------------------------
1856	// [SECTION] Box-select support
1857	//-----------------------------------------------------------------------------
1858
1859	struct ImGuiBoxSelectState
1860	{
1861	// Active box-selection data (persistent, 1 active at a time)
1862	ImGuiID ID;
1863	bool IsActive;
1864	bool IsStarting;
1865	bool IsStartedFromVoid; // Starting click was not from an item.
1866	bool IsStartedSetNavIdOnce;
1867	bool RequestClear;
1868	ImGuiKeyChord KeyMods : 16; // Latched key-mods for box-select logic.
1869	ImVec2 StartPosRel; // Start position in window-contents relative space (to support scrolling)
1870	ImVec2 EndPosRel; // End position in window-contents relative space
1871	ImVec2 ScrollAccum; // Scrolling accumulator (to behave at high-frame spaces)
1872	ImGuiWindow* Window;
1873
1874	// Temporary/Transient data
1875	bool UnclipMode; // (Temp/Transient, here in hot area). Set/cleared by the BeginMultiSelect()/EndMultiSelect() owning active box-select.
1876	ImRect UnclipRect; // Rectangle where ItemAdd() clipping may be temporarily disabled. Need support by multi-select supporting widgets.
1877	ImRect BoxSelectRectPrev; // Selection rectangle in absolute coordinates (derived every frame from BoxSelectStartPosRel and MousePos)
1878	ImRect BoxSelectRectCurr;
1879
1880	ImGuiBoxSelectState() { memset(s: this, c: 0, n: sizeof(*this)); }
1881	};
1882
1883	//-----------------------------------------------------------------------------
1884	// [SECTION] Multi-select support
1885	//-----------------------------------------------------------------------------
1886
1887	// We always assume that -1 is an invalid value (which works for indices and pointers)
1888	#define ImGuiSelectionUserData_Invalid ((ImGuiSelectionUserData)-1)
1889
1890	// Temporary storage for multi-select
1891	struct IMGUI_API ImGuiMultiSelectTempData
1892	{
1893	ImGuiMultiSelectIO IO; // MUST BE FIRST FIELD. Requests are set and returned by BeginMultiSelect()/EndMultiSelect() + written to by user during the loop.
1894	ImGuiMultiSelectState* Storage;
1895	ImGuiID FocusScopeId; // Copied from g.CurrentFocusScopeId (unless another selection scope was pushed manually)
1896	ImGuiMultiSelectFlags Flags;
1897	ImVec2 ScopeRectMin;
1898	ImVec2 BackupCursorMaxPos;
1899	ImGuiSelectionUserData LastSubmittedItem; // Copy of last submitted item data, used to merge output ranges.
1900	ImGuiID BoxSelectId;
1901	ImGuiKeyChord KeyMods;
1902	ImS8 LoopRequestSetAll; // -1: no operation, 0: clear all, 1: select all.
1903	bool IsEndIO; // Set when switching IO from BeginMultiSelect() to EndMultiSelect() state.
1904	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.
1905	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.
1906	bool NavIdPassedBy;
1907	bool RangeSrcPassedBy; // Set by the item that matches RangeSrcItem.
1908	bool RangeDstPassedBy; // Set by the item that matches NavJustMovedToId when IsSetRange is set.
1909
1910	ImGuiMultiSelectTempData() { Clear(); }
1911	void Clear() { size_t io_sz = sizeof(IO); ClearIO(); memset(s: (void*)(&IO + 1), c: 0, n: sizeof(*this) - io_sz); } // Zero-clear except IO as we preserve IO.Requests[] buffer allocation.
1912	void ClearIO() { IO.Requests.resize(new_size: 0); IO.RangeSrcItem = IO.NavIdItem = ImGuiSelectionUserData_Invalid; IO.NavIdSelected = IO.RangeSrcReset = false; }
1913	};
1914
1915	// Persistent storage for multi-select (as long as selection is alive)
1916	struct IMGUI_API ImGuiMultiSelectState
1917	{
1918	ImGuiWindow* Window;
1919	ImGuiID ID;
1920	int LastFrameActive; // Last used frame-count, for GC.
1921	int LastSelectionSize; // Set by BeginMultiSelect() based on optional info provided by user. May be -1 if unknown.
1922	ImS8 RangeSelected; // -1 (don't have) or true/false
1923	ImS8 NavIdSelected; // -1 (don't have) or true/false
1924	ImGuiSelectionUserData RangeSrcItem; //
1925	ImGuiSelectionUserData NavIdItem; // SetNextItemSelectionUserData() value for NavId (if part of submitted items)
1926
1927	ImGuiMultiSelectState() { Window = NULL; ID = 0; LastFrameActive = LastSelectionSize = 0; RangeSelected = NavIdSelected = -1; RangeSrcItem = NavIdItem = ImGuiSelectionUserData_Invalid; }
1928	};
1929
1930	//-----------------------------------------------------------------------------
1931	// [SECTION] Docking support
1932	//-----------------------------------------------------------------------------
1933
1934	#define DOCKING_HOST_DRAW_CHANNEL_BG 0 // Dock host: background fill
1935	#define DOCKING_HOST_DRAW_CHANNEL_FG 1 // Dock host: decorations and contents
1936
1937	#ifdef IMGUI_HAS_DOCK
1938
1939	// Extend ImGuiDockNodeFlags_
1940	enum ImGuiDockNodeFlagsPrivate_
1941	{
1942	// [Internal]
1943	ImGuiDockNodeFlags_DockSpace = 1 << 10, // Saved // A dockspace is a node that occupy space within an existing user window. Otherwise the node is floating and create its own window.
1944	ImGuiDockNodeFlags_CentralNode = 1 << 11, // Saved // The central node has 2 main properties: stay visible when empty, only use "remaining" spaces from its neighbor.
1945	ImGuiDockNodeFlags_NoTabBar = 1 << 12, // Saved // Tab bar is completely unavailable. No triangle in the corner to enable it back.
1946	ImGuiDockNodeFlags_HiddenTabBar = 1 << 13, // Saved // Tab bar is hidden, with a triangle in the corner to show it again (NB: actual tab-bar instance may be destroyed as this is only used for single-window tab bar)
1947	ImGuiDockNodeFlags_NoWindowMenuButton = 1 << 14, // Saved // Disable window/docking menu (that one that appears instead of the collapse button)
1948	ImGuiDockNodeFlags_NoCloseButton = 1 << 15, // Saved // Disable close button
1949	ImGuiDockNodeFlags_NoResizeX = 1 << 16, // //
1950	ImGuiDockNodeFlags_NoResizeY = 1 << 17, // //
1951	ImGuiDockNodeFlags_DockedWindowsInFocusRoute= 1 << 18, // // Any docked window will be automatically be focus-route chained (window->ParentWindowForFocusRoute set to this) so Shortcut() in this window can run when any docked window is focused.
1952
1953	// Disable docking/undocking actions in this dockspace or individual node (existing docked nodes will be preserved)
1954	// Those are not exposed in public because the desirable sharing/inheriting/copy-flag-on-split behaviors are quite difficult to design and understand.
1955	// The two public flags ImGuiDockNodeFlags_NoDockingOverCentralNode/ImGuiDockNodeFlags_NoDockingSplit don't have those issues.
1956	ImGuiDockNodeFlags_NoDockingSplitOther = 1 << 19, // // Disable this node from splitting other windows/nodes.
1957	ImGuiDockNodeFlags_NoDockingOverMe = 1 << 20, // // Disable other windows/nodes from being docked over this node.
1958	ImGuiDockNodeFlags_NoDockingOverOther = 1 << 21, // // Disable this node from being docked over another window or non-empty node.
1959	ImGuiDockNodeFlags_NoDockingOverEmpty = 1 << 22, // // Disable this node from being docked over an empty node (e.g. DockSpace with no other windows)
1960	ImGuiDockNodeFlags_NoDocking = ImGuiDockNodeFlags_NoDockingOverMe | ImGuiDockNodeFlags_NoDockingOverOther | ImGuiDockNodeFlags_NoDockingOverEmpty | ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoDockingSplitOther,
1961
1962	// Masks
1963	ImGuiDockNodeFlags_SharedFlagsInheritMask_ = ~0,
1964	ImGuiDockNodeFlags_NoResizeFlagsMask_ = (int)ImGuiDockNodeFlags_NoResize | ImGuiDockNodeFlags_NoResizeX | ImGuiDockNodeFlags_NoResizeY,
1965
1966	// When splitting, those local flags are moved to the inheriting child, never duplicated
1967	ImGuiDockNodeFlags_LocalFlagsTransferMask_ = (int)ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoResizeFlagsMask_ | (int)ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton,
1968	ImGuiDockNodeFlags_SavedFlagsMask_ = ImGuiDockNodeFlags_NoResizeFlagsMask_ | ImGuiDockNodeFlags_DockSpace | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton,
1969	};
1970
1971	// Store the source authority (dock node vs window) of a field
1972	enum ImGuiDataAuthority_
1973	{
1974	ImGuiDataAuthority_Auto,
1975	ImGuiDataAuthority_DockNode,
1976	ImGuiDataAuthority_Window,
1977	};
1978
1979	enum ImGuiDockNodeState
1980	{
1981	ImGuiDockNodeState_Unknown,
1982	ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow,
1983	ImGuiDockNodeState_HostWindowHiddenBecauseWindowsAreResizing,
1984	ImGuiDockNodeState_HostWindowVisible,
1985	};
1986
1987	// sizeof() 156~192
1988	struct IMGUI_API ImGuiDockNode
1989	{
1990	ImGuiID ID;
1991	ImGuiDockNodeFlags SharedFlags; // (Write) Flags shared by all nodes of a same dockspace hierarchy (inherited from the root node)
1992	ImGuiDockNodeFlags LocalFlags; // (Write) Flags specific to this node
1993	ImGuiDockNodeFlags LocalFlagsInWindows; // (Write) Flags specific to this node, applied from windows
1994	ImGuiDockNodeFlags MergedFlags; // (Read) Effective flags (== SharedFlags | LocalFlagsInNode | LocalFlagsInWindows)
1995	ImGuiDockNodeState State;
1996	ImGuiDockNode* ParentNode;
1997	ImGuiDockNode* ChildNodes[2]; // [Split node only] Child nodes (left/right or top/bottom). Consider switching to an array.
1998	ImVector<ImGuiWindow*> Windows; // Note: unordered list! Iterate TabBar->Tabs for user-order.
1999	ImGuiTabBar* TabBar;
2000	ImVec2 Pos; // Current position
2001	ImVec2 Size; // Current size
2002	ImVec2 SizeRef; // [Split node only] Last explicitly written-to size (overridden when using a splitter affecting the node), used to calculate Size.
2003	ImGuiAxis SplitAxis; // [Split node only] Split axis (X or Y)
2004	ImGuiWindowClass WindowClass; // [Root node only]
2005	ImU32 LastBgColor;
2006
2007	ImGuiWindow* HostWindow;
2008	ImGuiWindow* VisibleWindow; // Generally point to window which is ID is == SelectedTabID, but when CTRL+Tabbing this can be a different window.
2009	ImGuiDockNode* CentralNode; // [Root node only] Pointer to central node.
2010	ImGuiDockNode* OnlyNodeWithWindows; // [Root node only] Set when there is a single visible node within the hierarchy.
2011	int CountNodeWithWindows; // [Root node only]
2012	int LastFrameAlive; // Last frame number the node was updated or kept alive explicitly with DockSpace() + ImGuiDockNodeFlags_KeepAliveOnly
2013	int LastFrameActive; // Last frame number the node was updated.
2014	int LastFrameFocused; // Last frame number the node was focused.
2015	ImGuiID LastFocusedNodeId; // [Root node only] Which of our child docking node (any ancestor in the hierarchy) was last focused.
2016	ImGuiID SelectedTabId; // [Leaf node only] Which of our tab/window is selected.
2017	ImGuiID WantCloseTabId; // [Leaf node only] Set when closing a specific tab/window.
2018	ImGuiID RefViewportId; // Reference viewport ID from visible window when HostWindow == NULL.
2019	ImGuiDataAuthority AuthorityForPos :3;
2020	ImGuiDataAuthority AuthorityForSize :3;
2021	ImGuiDataAuthority AuthorityForViewport :3;
2022	bool IsVisible :1; // Set to false when the node is hidden (usually disabled as it has no active window)
2023	bool IsFocused :1;
2024	bool IsBgDrawnThisFrame :1;
2025	bool HasCloseButton :1; // Provide space for a close button (if any of the docked window has one). Note that button may be hidden on window without one.
2026	bool HasWindowMenuButton :1;
2027	bool HasCentralNodeChild :1;
2028	bool WantCloseAll :1; // Set when closing all tabs at once.
2029	bool WantLockSizeOnce :1;
2030	bool WantMouseMove :1; // After a node extraction we need to transition toward moving the newly created host window
2031	bool WantHiddenTabBarUpdate :1;
2032	bool WantHiddenTabBarToggle :1;
2033
2034	ImGuiDockNode(ImGuiID id);
2035	~ImGuiDockNode();
2036	bool IsRootNode() const { return ParentNode == NULL; }
2037	bool IsDockSpace() const { return (MergedFlags & ImGuiDockNodeFlags_DockSpace) != 0; }
2038	bool IsFloatingNode() const { return ParentNode == NULL && (MergedFlags & ImGuiDockNodeFlags_DockSpace) == 0; }
2039	bool IsCentralNode() const { return (MergedFlags & ImGuiDockNodeFlags_CentralNode) != 0; }
2040	bool IsHiddenTabBar() const { return (MergedFlags & ImGuiDockNodeFlags_HiddenTabBar) != 0; } // Hidden tab bar can be shown back by clicking the small triangle
2041	bool IsNoTabBar() const { return (MergedFlags & ImGuiDockNodeFlags_NoTabBar) != 0; } // Never show a tab bar
2042	bool IsSplitNode() const { return ChildNodes[0] != NULL; }
2043	bool IsLeafNode() const { return ChildNodes[0] == NULL; }
2044	bool IsEmpty() const { return ChildNodes[0] == NULL && Windows.Size == 0; }
2045	ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
2046
2047	void SetLocalFlags(ImGuiDockNodeFlags flags) { LocalFlags = flags; UpdateMergedFlags(); }
2048	void UpdateMergedFlags() { MergedFlags = SharedFlags | LocalFlags | LocalFlagsInWindows; }
2049	};
2050
2051	// List of colors that are stored at the time of Begin() into Docked Windows.
2052	// We currently store the packed colors in a simple array window->DockStyle.Colors[].
2053	// A better solution may involve appending into a log of colors in ImGuiContext + store offsets into those arrays in ImGuiWindow,
2054	// but it would be more complex as we'd need to double-buffer both as e.g. drop target may refer to window from last frame.
2055	enum ImGuiWindowDockStyleCol
2056	{
2057	ImGuiWindowDockStyleCol_Text,
2058	ImGuiWindowDockStyleCol_TabHovered,
2059	ImGuiWindowDockStyleCol_TabFocused,
2060	ImGuiWindowDockStyleCol_TabSelected,
2061	ImGuiWindowDockStyleCol_TabSelectedOverline,
2062	ImGuiWindowDockStyleCol_TabDimmed,
2063	ImGuiWindowDockStyleCol_TabDimmedSelected,
2064	ImGuiWindowDockStyleCol_TabDimmedSelectedOverline,
2065	ImGuiWindowDockStyleCol_COUNT
2066	};
2067
2068	// We don't store style.Alpha: dock_node->LastBgColor embeds it and otherwise it would only affect the docking tab, which intuitively I would say we don't want to.
2069	struct ImGuiWindowDockStyle
2070	{
2071	ImU32 Colors[ImGuiWindowDockStyleCol_COUNT];
2072	};
2073
2074	struct ImGuiDockContext
2075	{
2076	ImGuiStorage Nodes; // Map ID -> ImGuiDockNode*: Active nodes
2077	ImVector<ImGuiDockRequest> Requests;
2078	ImVector<ImGuiDockNodeSettings> NodesSettings;
2079	bool WantFullRebuild;
2080	ImGuiDockContext() { memset(s: this, c: 0, n: sizeof(*this)); }
2081	};
2082
2083	#endif // #ifdef IMGUI_HAS_DOCK
2084
2085	//-----------------------------------------------------------------------------
2086	// [SECTION] Viewport support
2087	//-----------------------------------------------------------------------------
2088
2089	// ImGuiViewport Private/Internals fields (cardinal sin: we are using inheritance!)
2090	// Every instance of ImGuiViewport is in fact a ImGuiViewportP.
2091	struct ImGuiViewportP : public ImGuiViewport
2092	{
2093	ImGuiWindow* Window; // Set when the viewport is owned by a window (and ImGuiViewportFlags_CanHostOtherWindows is NOT set)
2094	int Idx;
2095	int LastFrameActive; // Last frame number this viewport was activated by a window
2096	int LastFocusedStampCount; // Last stamp number from when a window hosted by this viewport was focused (by comparing this value between two viewport we have an implicit viewport z-order we use as fallback)
2097	ImGuiID LastNameHash;
2098	ImVec2 LastPos;
2099	ImVec2 LastSize;
2100	float Alpha; // Window opacity (when dragging dockable windows/viewports we make them transparent)
2101	float LastAlpha;
2102	bool LastFocusedHadNavWindow;// Instead of maintaining a LastFocusedWindow (which may harder to correctly maintain), we merely store weither NavWindow != NULL last time the viewport was focused.
2103	short PlatformMonitor;
2104	int BgFgDrawListsLastFrame[2]; // Last frame number the background (0) and foreground (1) draw lists were used
2105	ImDrawList* BgFgDrawLists[2]; // Convenience background (0) and foreground (1) draw lists. We use them to draw software mouser cursor when io.MouseDrawCursor is set and to draw most debug overlays.
2106	ImDrawData DrawDataP;
2107	ImDrawDataBuilder DrawDataBuilder; // Temporary data while building final ImDrawData
2108	ImVec2 LastPlatformPos;
2109	ImVec2 LastPlatformSize;
2110	ImVec2 LastRendererSize;
2111
2112	// Per-viewport work area
2113	// - Insets are >= 0.0f values, distance from viewport corners to work area.
2114	// - BeginMainMenuBar() and DockspaceOverViewport() tend to use work area to avoid stepping over existing contents.
2115	// - Generally 'safeAreaInsets' in iOS land, 'DisplayCutout' in Android land.
2116	ImVec2 WorkInsetMin; // Work Area inset locked for the frame. GetWorkRect() always fits within GetMainRect().
2117	ImVec2 WorkInsetMax; // "
2118	ImVec2 BuildWorkInsetMin; // Work Area inset accumulator for current frame, to become next frame's WorkInset
2119	ImVec2 BuildWorkInsetMax; // "
2120
2121	ImGuiViewportP() { Window = NULL; Idx = -1; LastFrameActive = BgFgDrawListsLastFrame[0] = BgFgDrawListsLastFrame[1] = LastFocusedStampCount = -1; LastNameHash = 0; Alpha = LastAlpha = 1.0f; LastFocusedHadNavWindow = false; PlatformMonitor = -1; BgFgDrawLists[0] = BgFgDrawLists[1] = NULL; LastPlatformPos = LastPlatformSize = LastRendererSize = ImVec2(FLT_MAX, FLT_MAX); }
2122	~ImGuiViewportP() { if (BgFgDrawLists[0]) IM_DELETE(p: BgFgDrawLists[0]); if (BgFgDrawLists[1]) IM_DELETE(p: BgFgDrawLists[1]); }
2123	void ClearRequestFlags() { PlatformRequestClose = PlatformRequestMove = PlatformRequestResize = false; }
2124
2125	// Calculate work rect pos/size given a set of offset (we have 1 pair of offset for rect locked from last frame data, and 1 pair for currently building rect)
2126	ImVec2 CalcWorkRectPos(const ImVec2& inset_min) const { return ImVec2(Pos.x + inset_min.x, Pos.y + inset_min.y); }
2127	ImVec2 CalcWorkRectSize(const ImVec2& inset_min, const ImVec2& inset_max) const { return ImVec2(ImMax(lhs: 0.0f, rhs: Size.x - inset_min.x - inset_max.x), ImMax(lhs: 0.0f, rhs: Size.y - inset_min.y - inset_max.y)); }
2128	void UpdateWorkRect() { WorkPos = CalcWorkRectPos(inset_min: WorkInsetMin); WorkSize = CalcWorkRectSize(inset_min: WorkInsetMin, inset_max: WorkInsetMax); } // Update public fields
2129
2130	// Helpers to retrieve ImRect (we don't need to store BuildWorkRect as every access tend to change it, hence the code asymmetry)
2131	ImRect GetMainRect() const { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
2132	ImRect GetWorkRect() const { return ImRect(WorkPos.x, WorkPos.y, WorkPos.x + WorkSize.x, WorkPos.y + WorkSize.y); }
2133	ImRect GetBuildWorkRect() const { ImVec2 pos = CalcWorkRectPos(inset_min: BuildWorkInsetMin); ImVec2 size = CalcWorkRectSize(inset_min: BuildWorkInsetMin, inset_max: BuildWorkInsetMax); return ImRect(pos.x, pos.y, pos.x + size.x, pos.y + size.y); }
2134	};
2135
2136	//-----------------------------------------------------------------------------
2137	// [SECTION] Settings support
2138	//-----------------------------------------------------------------------------
2139
2140	// Windows data saved in imgui.ini file
2141	// Because we never destroy or rename ImGuiWindowSettings, we can store the names in a separate buffer easily.
2142	// (this is designed to be stored in a ImChunkStream buffer, with the variable-length Name following our structure)
2143	struct ImGuiWindowSettings
2144	{
2145	ImGuiID ID;
2146	ImVec2ih Pos; // NB: Settings position are stored RELATIVE to the viewport! Whereas runtime ones are absolute positions.
2147	ImVec2ih Size;
2148	ImVec2ih ViewportPos;
2149	ImGuiID ViewportId;
2150	ImGuiID DockId; // ID of last known DockNode (even if the DockNode is invisible because it has only 1 active window), or 0 if none.
2151	ImGuiID ClassId; // ID of window class if specified
2152	short DockOrder; // Order of the last time the window was visible within its DockNode. This is used to reorder windows that are reappearing on the same frame. Same value between windows that were active and windows that were none are possible.
2153	bool Collapsed;
2154	bool IsChild;
2155	bool WantApply; // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)
2156	bool WantDelete; // Set to invalidate/delete the settings entry
2157
2158	ImGuiWindowSettings() { memset(s: this, c: 0, n: sizeof(*this)); DockOrder = -1; }
2159	char* GetName() { return (char*)(this + 1); }
2160	};
2161
2162	struct ImGuiSettingsHandler
2163	{
2164	const char* TypeName; // Short description stored in .ini file. Disallowed characters: '[' ']'
2165	ImGuiID TypeHash; // == ImHashStr(TypeName)
2166	void (*ClearAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Clear all settings data
2167	void (*ReadInitFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Read: Called before reading (in registration order)
2168	void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name); // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
2169	void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry
2170	void (*ApplyAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Read: Called after reading (in registration order)
2171	void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf); // Write: Output every entries into 'out_buf'
2172	void* UserData;
2173
2174	ImGuiSettingsHandler() { memset(s: this, c: 0, n: sizeof(*this)); }
2175	};
2176
2177	//-----------------------------------------------------------------------------
2178	// [SECTION] Localization support
2179	//-----------------------------------------------------------------------------
2180
2181	// This is experimental and not officially supported, it'll probably fall short of features, if/when it does we may backtrack.
2182	enum ImGuiLocKey : int
2183	{
2184	ImGuiLocKey_VersionStr,
2185	ImGuiLocKey_TableSizeOne,
2186	ImGuiLocKey_TableSizeAllFit,
2187	ImGuiLocKey_TableSizeAllDefault,
2188	ImGuiLocKey_TableResetOrder,
2189	ImGuiLocKey_WindowingMainMenuBar,
2190	ImGuiLocKey_WindowingPopup,
2191	ImGuiLocKey_WindowingUntitled,
2192	ImGuiLocKey_OpenLink_s,
2193	ImGuiLocKey_CopyLink,
2194	ImGuiLocKey_DockingHideTabBar,
2195	ImGuiLocKey_DockingHoldShiftToDock,
2196	ImGuiLocKey_DockingDragToUndockOrMoveNode,
2197	ImGuiLocKey_COUNT
2198	};
2199
2200	struct ImGuiLocEntry
2201	{
2202	ImGuiLocKey Key;
2203	const char* Text;
2204	};
2205
2206	//-----------------------------------------------------------------------------
2207	// [SECTION] Error handling, State recovery support
2208	//-----------------------------------------------------------------------------
2209
2210	// Macros used by Recoverable Error handling
2211	// - Only dispatch error if _EXPR: evaluate as assert (similar to an assert macro).
2212	// - The message will always be a string literal, in order to increase likelihood of being display by an assert handler.
2213	// - See 'Demo->Configuration->Error Handling' and ImGuiIO definitions for details on error handling.
2214	// - Read https://github.com/ocornut/imgui/wiki/Error-Handling for details on error handling.
2215	#ifndef IM_ASSERT_USER_ERROR
2216	#define IM_ASSERT_USER_ERROR(_EXPR,_MSG) do { if (!(_EXPR) && ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } } while (0) // Recoverable User Error
2217	#endif
2218
2219	// The error callback is currently not public, as it is expected that only advanced users will rely on it.
2220	typedef void (*ImGuiErrorCallback)(ImGuiContext* ctx, void* user_data, const char* msg); // Function signature for g.ErrorCallback
2221
2222	//-----------------------------------------------------------------------------
2223	// [SECTION] Metrics, Debug Tools
2224	//-----------------------------------------------------------------------------
2225
2226	// See IMGUI_DEBUG_LOG() and IMGUI_DEBUG_LOG_XXX() macros.
2227	enum ImGuiDebugLogFlags_
2228	{
2229	// Event types
2230	ImGuiDebugLogFlags_None = 0,
2231	ImGuiDebugLogFlags_EventError = 1 << 0, // Error submitted by IM_ASSERT_USER_ERROR()
2232	ImGuiDebugLogFlags_EventActiveId = 1 << 1,
2233	ImGuiDebugLogFlags_EventFocus = 1 << 2,
2234	ImGuiDebugLogFlags_EventPopup = 1 << 3,
2235	ImGuiDebugLogFlags_EventNav = 1 << 4,
2236	ImGuiDebugLogFlags_EventClipper = 1 << 5,
2237	ImGuiDebugLogFlags_EventSelection = 1 << 6,
2238	ImGuiDebugLogFlags_EventIO = 1 << 7,
2239	ImGuiDebugLogFlags_EventFont = 1 << 8,
2240	ImGuiDebugLogFlags_EventInputRouting = 1 << 9,
2241	ImGuiDebugLogFlags_EventDocking = 1 << 10,
2242	ImGuiDebugLogFlags_EventViewport = 1 << 11,
2243
2244	ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventError | ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventFont | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport,
2245	ImGuiDebugLogFlags_OutputToTTY = 1 << 20, // Also send output to TTY
2246	ImGuiDebugLogFlags_OutputToTestEngine = 1 << 21, // Also send output to Test Engine
2247	};
2248
2249	struct ImGuiDebugAllocEntry
2250	{
2251	int FrameCount;
2252	ImS16 AllocCount;
2253	ImS16 FreeCount;
2254	};
2255
2256	struct ImGuiDebugAllocInfo
2257	{
2258	int TotalAllocCount; // Number of call to MemAlloc().
2259	int TotalFreeCount;
2260	ImS16 LastEntriesIdx; // Current index in buffer
2261	ImGuiDebugAllocEntry LastEntriesBuf[6]; // Track last 6 frames that had allocations
2262
2263	ImGuiDebugAllocInfo() { memset(s: this, c: 0, n: sizeof(*this)); }
2264	};
2265
2266	struct ImGuiMetricsConfig
2267	{
2268	bool ShowDebugLog = false;
2269	bool ShowIDStackTool = false;
2270	bool ShowWindowsRects = false;
2271	bool ShowWindowsBeginOrder = false;
2272	bool ShowTablesRects = false;
2273	bool ShowDrawCmdMesh = true;
2274	bool ShowDrawCmdBoundingBoxes = true;
2275	bool ShowTextEncodingViewer = false;
2276	bool ShowTextureUsedRect = false;
2277	bool ShowDockingNodes = false;
2278	int ShowWindowsRectsType = -1;
2279	int ShowTablesRectsType = -1;
2280	int HighlightMonitorIdx = -1;
2281	ImGuiID HighlightViewportID = 0;
2282	bool ShowFontPreview = true;
2283	};
2284
2285	struct ImGuiStackLevelInfo
2286	{
2287	ImGuiID ID;
2288	ImS8 QueryFrameCount; // >= 1: Query in progress
2289	bool QuerySuccess; // Obtained result from DebugHookIdInfo()
2290	ImGuiDataType DataType : 8;
2291	char Desc[57]; // Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?) FIXME: Now that we added CTRL+C this should be fixed.
2292
2293	ImGuiStackLevelInfo() { memset(s: this, c: 0, n: sizeof(*this)); }
2294	};
2295
2296	// State for ID Stack tool queries
2297	struct ImGuiIDStackTool
2298	{
2299	int LastActiveFrame;
2300	int StackLevel; // -1: query stack and resize Results, >= 0: individual stack level
2301	ImGuiID QueryId; // ID to query details for
2302	ImVector<ImGuiStackLevelInfo> Results;
2303	bool CopyToClipboardOnCtrlC;
2304	float CopyToClipboardLastTime;
2305	ImGuiTextBuffer ResultPathBuf;
2306
2307	ImGuiIDStackTool() { memset(s: this, c: 0, n: sizeof(*this)); CopyToClipboardLastTime = -FLT_MAX; }
2308	};
2309
2310	//-----------------------------------------------------------------------------
2311	// [SECTION] Generic context hooks
2312	//-----------------------------------------------------------------------------
2313
2314	typedef void (*ImGuiContextHookCallback)(ImGuiContext* ctx, ImGuiContextHook* hook);
2315	enum ImGuiContextHookType { ImGuiContextHookType_NewFramePre, ImGuiContextHookType_NewFramePost, ImGuiContextHookType_EndFramePre, ImGuiContextHookType_EndFramePost, ImGuiContextHookType_RenderPre, ImGuiContextHookType_RenderPost, ImGuiContextHookType_Shutdown, ImGuiContextHookType_PendingRemoval_ };
2316
2317	struct ImGuiContextHook
2318	{
2319	ImGuiID HookId; // A unique ID assigned by AddContextHook()
2320	ImGuiContextHookType Type;
2321	ImGuiID Owner;
2322	ImGuiContextHookCallback Callback;
2323	void* UserData;
2324
2325	ImGuiContextHook() { memset(s: this, c: 0, n: sizeof(*this)); }
2326	};
2327
2328	//-----------------------------------------------------------------------------
2329	// [SECTION] ImGuiContext (main Dear ImGui context)
2330	//-----------------------------------------------------------------------------
2331
2332	struct ImGuiContext
2333	{
2334	bool Initialized;
2335	ImGuiIO IO;
2336	ImGuiPlatformIO PlatformIO;
2337	ImGuiStyle Style;
2338	ImGuiConfigFlags ConfigFlagsCurrFrame; // = g.IO.ConfigFlags at the time of NewFrame()
2339	ImGuiConfigFlags ConfigFlagsLastFrame;
2340	ImVector<ImFontAtlas*> FontAtlases; // List of font atlases used by the context (generally only contains g.IO.Fonts aka the main font atlas)
2341	ImFont* Font; // Currently bound font. (== FontStack.back().Font)
2342	ImFontBaked* FontBaked; // Currently bound font at currently bound size. (== Font->GetFontBaked(FontSize))
2343	float FontSize; // Currently bound font size == line height (== FontSizeBase + externals scales applied in the UpdateCurrentFontSize() function).
2344	float FontSizeBase; // Font size before scaling == style.FontSizeBase == value passed to PushFont() when specified.
2345	float FontBakedScale; // == FontBaked->Size / FontSize. Scale factor over baked size. Rarely used nowadays, very often == 1.0f.
2346	float FontRasterizerDensity; // Current font density. Used by all calls to GetFontBaked().
2347	float CurrentDpiScale; // Current window/viewport DpiScale == CurrentViewport->DpiScale
2348	ImDrawListSharedData DrawListSharedData;
2349	double Time;
2350	int FrameCount;
2351	int FrameCountEnded;
2352	int FrameCountPlatformEnded;
2353	int FrameCountRendered;
2354	ImGuiID WithinEndChildID; // Set within EndChild()
2355	bool WithinFrameScope; // Set by NewFrame(), cleared by EndFrame()
2356	bool WithinFrameScopeWithImplicitWindow; // Set by NewFrame(), cleared by EndFrame() when the implicit debug window has been pushed
2357	bool GcCompactAll; // Request full GC
2358	bool TestEngineHookItems; // Will call test engine hooks: ImGuiTestEngineHook_ItemAdd(), ImGuiTestEngineHook_ItemInfo(), ImGuiTestEngineHook_Log()
2359	void* TestEngine; // Test engine user data
2360	char ContextName[16]; // Storage for a context name (to facilitate debugging multi-context setups)
2361
2362	// Inputs
2363	ImVector<ImGuiInputEvent> InputEventsQueue; // Input events which will be trickled/written into IO structure.
2364	ImVector<ImGuiInputEvent> InputEventsTrail; // Past input events processed in NewFrame(). This is to allow domain-specific application to access e.g mouse/pen trail.
2365	ImGuiMouseSource InputEventsNextMouseSource;
2366	ImU32 InputEventsNextEventId;
2367
2368	// Windows state
2369	ImVector<ImGuiWindow*> Windows; // Windows, sorted in display order, back to front
2370	ImVector<ImGuiWindow*> WindowsFocusOrder; // Root windows, sorted in focus order, back to front.
2371	ImVector<ImGuiWindow*> WindowsTempSortBuffer; // Temporary buffer used in EndFrame() to reorder windows so parents are kept before their child
2372	ImVector<ImGuiWindowStackData> CurrentWindowStack;
2373	ImGuiStorage WindowsById; // Map window's ImGuiID to ImGuiWindow*
2374	int WindowsActiveCount; // Number of unique windows submitted by frame
2375	float WindowsBorderHoverPadding; // Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, style.WindowBorderHoverPadding). This isn't so multi-dpi friendly.
2376	ImGuiID DebugBreakInWindow; // Set to break in Begin() call.
2377	ImGuiWindow* CurrentWindow; // Window being drawn into
2378	ImGuiWindow* HoveredWindow; // Window the mouse is hovering. Will typically catch mouse inputs.
2379	ImGuiWindow* HoveredWindowUnderMovingWindow; // Hovered window ignoring MovingWindow. Only set if MovingWindow is set.
2380	ImGuiWindow* HoveredWindowBeforeClear; // Window the mouse is hovering. Filled even with _NoMouse. This is currently useful for multi-context compositors.
2381	ImGuiWindow* MovingWindow; // Track the window we clicked on (in order to preserve focus). The actual window that is moved is generally MovingWindow->RootWindowDockTree.
2382	ImGuiWindow* WheelingWindow; // Track the window we started mouse-wheeling on. Until a timer elapse or mouse has moved, generally keep scrolling the same window even if during the course of scrolling the mouse ends up hovering a child window.
2383	ImVec2 WheelingWindowRefMousePos;
2384	int WheelingWindowStartFrame; // This may be set one frame before WheelingWindow is != NULL
2385	int WheelingWindowScrolledFrame;
2386	float WheelingWindowReleaseTimer;
2387	ImVec2 WheelingWindowWheelRemainder;
2388	ImVec2 WheelingAxisAvg;
2389
2390	// Item/widgets state and tracking information
2391	ImGuiID DebugDrawIdConflictsId; // Set when we detect multiple items with the same identifier
2392	ImGuiID DebugHookIdInfo; // Will call core hooks: DebugHookIdInfo() from GetID functions, used by ID Stack Tool [next HoveredId/ActiveId to not pull in an extra cache-line]
2393	ImGuiID HoveredId; // Hovered widget, filled during the frame
2394	ImGuiID HoveredIdPreviousFrame;
2395	int HoveredIdPreviousFrameItemCount; // Count numbers of items using the same ID as last frame's hovered id
2396	float HoveredIdTimer; // Measure contiguous hovering time
2397	float HoveredIdNotActiveTimer; // Measure contiguous hovering time where the item has not been active
2398	bool HoveredIdAllowOverlap;
2399	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.
2400	bool ItemUnclipByLog; // Disable ItemAdd() clipping, essentially a memory-locality friendly copy of LogEnabled
2401	ImGuiID ActiveId; // Active widget
2402	ImGuiID ActiveIdIsAlive; // Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame)
2403	float ActiveIdTimer;
2404	bool ActiveIdIsJustActivated; // Set at the time of activation for one frame
2405	bool ActiveIdAllowOverlap; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
2406	bool ActiveIdNoClearOnFocusLoss; // Disable losing active id if the active id window gets unfocused.
2407	bool ActiveIdHasBeenPressedBefore; // Track whether the active id led to a press (this is to allow changing between PressOnClick and PressOnRelease without pressing twice). Used by range_select branch.
2408	bool ActiveIdHasBeenEditedBefore; // Was the value associated to the widget Edited over the course of the Active state.
2409	bool ActiveIdHasBeenEditedThisFrame;
2410	bool ActiveIdFromShortcut;
2411	ImGuiID ActiveIdDisabledId; // When clicking a disabled item we set ActiveId=window->MoveId to avoid interference with widget code. Actual item ID is stored here.
2412	int ActiveIdMouseButton : 8;
2413	ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
2414	ImGuiWindow* ActiveIdWindow;
2415	ImGuiInputSource ActiveIdSource; // Activating source: ImGuiInputSource_Mouse OR ImGuiInputSource_Keyboard OR ImGuiInputSource_Gamepad
2416	ImGuiID ActiveIdPreviousFrame;
2417	ImGuiDeactivatedItemData DeactivatedItemData;
2418	ImGuiDataTypeStorage ActiveIdValueOnActivation; // Backup of initial value at the time of activation. ONLY SET BY SPECIFIC WIDGETS: DragXXX and SliderXXX.
2419	ImGuiID LastActiveId; // Store the last non-zero ActiveId, useful for animation.
2420	float LastActiveIdTimer; // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation.
2421
2422	// Key/Input Ownership + Shortcut Routing system
2423	// - The idea is that instead of "eating" a given key, we can link to an owner.
2424	// - Input query can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID.
2425	// - Routing is requested ahead of time for a given chord (Key + Mods) and granted in NewFrame().
2426	double LastKeyModsChangeTime; // Record the last time key mods changed (affect repeat delay when using shortcut logic)
2427	double LastKeyModsChangeFromNoneTime; // Record the last time key mods changed away from being 0 (affect repeat delay when using shortcut logic)
2428	double LastKeyboardKeyPressTime; // Record the last time a keyboard key (ignore mouse/gamepad ones) was pressed.
2429	ImBitArrayForNamedKeys KeysMayBeCharInput; // Lookup to tell if a key can emit char input, see IsKeyChordPotentiallyCharInput(). sizeof() = 20 bytes
2430	ImGuiKeyOwnerData KeysOwnerData[ImGuiKey_NamedKey_COUNT];
2431	ImGuiKeyRoutingTable KeysRoutingTable;
2432	ImU32 ActiveIdUsingNavDirMask; // Active widget will want to read those nav move requests (e.g. can activate a button and move away from it)
2433	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)
2434	ImGuiKeyChord DebugBreakInShortcutRouting; // Set to break in SetShortcutRouting()/Shortcut() calls.
2435	//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);'
2436
2437	// Next window/item data
2438	ImGuiID CurrentFocusScopeId; // Value for currently appending items == g.FocusScopeStack.back(). Not to be mistaken with g.NavFocusScopeId.
2439	ImGuiItemFlags CurrentItemFlags; // Value for currently appending items == g.ItemFlagsStack.back()
2440	ImGuiID DebugLocateId; // Storage for DebugLocateItemOnHover() feature: this is read by ItemAdd() so we keep it in a hot/cached location
2441	ImGuiNextItemData NextItemData; // Storage for SetNextItem** functions
2442	ImGuiLastItemData LastItemData; // Storage for last submitted item (setup by ItemAdd)
2443	ImGuiNextWindowData NextWindowData; // Storage for SetNextWindow** functions
2444	bool DebugShowGroupRects;
2445
2446	// Shared stacks
2447	ImGuiCol DebugFlashStyleColorIdx; // (Keep close to ColorStack to share cache line)
2448	ImVector<ImGuiColorMod> ColorStack; // Stack for PushStyleColor()/PopStyleColor() - inherited by Begin()
2449	ImVector<ImGuiStyleMod> StyleVarStack; // Stack for PushStyleVar()/PopStyleVar() - inherited by Begin()
2450	ImVector<ImFontStackData> FontStack; // Stack for PushFont()/PopFont() - inherited by Begin()
2451	ImVector<ImGuiFocusScopeData> FocusScopeStack; // Stack for PushFocusScope()/PopFocusScope() - inherited by BeginChild(), pushed into by Begin()
2452	ImVector<ImGuiItemFlags> ItemFlagsStack; // Stack for PushItemFlag()/PopItemFlag() - inherited by Begin()
2453	ImVector<ImGuiGroupData> GroupStack; // Stack for BeginGroup()/EndGroup() - not inherited by Begin()
2454	ImVector<ImGuiPopupData> OpenPopupStack; // Which popups are open (persistent)
2455	ImVector<ImGuiPopupData> BeginPopupStack; // Which level of BeginPopup() we are in (reset every frame)
2456	ImVector<ImGuiTreeNodeStackData>TreeNodeStack; // Stack for TreeNode()
2457
2458	// Viewports
2459	ImVector<ImGuiViewportP*> Viewports; // Active viewports (always 1+, and generally 1 unless multi-viewports are enabled). Each viewports hold their copy of ImDrawData.
2460	ImGuiViewportP* CurrentViewport; // We track changes of viewport (happening in Begin) so we can call Platform_OnChangedViewport()
2461	ImGuiViewportP* MouseViewport;
2462	ImGuiViewportP* MouseLastHoveredViewport; // Last known viewport that was hovered by mouse (even if we are not hovering any viewport any more) + honoring the _NoInputs flag.
2463	ImGuiID PlatformLastFocusedViewportId;
2464	ImGuiPlatformMonitor FallbackMonitor; // Virtual monitor used as fallback if backend doesn't provide monitor information.
2465	ImRect PlatformMonitorsFullWorkRect; // Bounding box of all platform monitors
2466	int ViewportCreatedCount; // Unique sequential creation counter (mostly for testing/debugging)
2467	int PlatformWindowsCreatedCount; // Unique sequential creation counter (mostly for testing/debugging)
2468	int ViewportFocusedStampCount; // Every time the front-most window changes, we stamp its viewport with an incrementing counter
2469
2470	// Keyboard/Gamepad Navigation
2471	bool NavCursorVisible; // Nav focus cursor/rectangle is visible? We hide it after a mouse click. We show it after a nav move.
2472	bool NavHighlightItemUnderNav; // Disable mouse hovering highlight. Highlight navigation focused item instead of mouse hovered item.
2473	//bool NavDisableHighlight; // Old name for !g.NavCursorVisible before 1.91.4 (2024/10/18). OPPOSITE VALUE (g.NavDisableHighlight == !g.NavCursorVisible)
2474	//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.
2475	bool NavMousePosDirty; // When set we will update mouse position if io.ConfigNavMoveSetMousePos is set (not enabled by default)
2476	bool NavIdIsAlive; // Nav widget has been seen this frame ~~ NavRectRel is valid
2477	ImGuiID NavId; // Focused item for navigation
2478	ImGuiWindow* NavWindow; // Focused window for navigation. Could be called 'FocusedWindow'
2479	ImGuiID NavFocusScopeId; // Focused focus scope (e.g. selection code often wants to "clear other items" when landing on an item of the same scope)
2480	ImGuiNavLayer NavLayer; // Focused layer (main scrolling layer, or menu/title bar layer)
2481	ImGuiID NavActivateId; // ~~ (g.ActiveId == 0) && (IsKeyPressed(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate)) ? NavId : 0, also set when calling ActivateItemByID()
2482	ImGuiID NavActivateDownId; // ~~ IsKeyDown(ImGuiKey_Space) || IsKeyDown(ImGuiKey_Enter) || IsKeyDown(ImGuiKey_NavGamepadActivate) ? NavId : 0
2483	ImGuiID NavActivatePressedId; // ~~ IsKeyPressed(ImGuiKey_Space) || IsKeyPressed(ImGuiKey_Enter) || IsKeyPressed(ImGuiKey_NavGamepadActivate) ? NavId : 0 (no repeat)
2484	ImGuiActivateFlags NavActivateFlags;
2485	ImVector<ImGuiFocusScopeData> NavFocusRoute; // Reversed copy focus scope stack for NavId (should contains NavFocusScopeId). This essentially follow the window->ParentWindowForFocusRoute chain.
2486	ImGuiID NavHighlightActivatedId;
2487	float NavHighlightActivatedTimer;
2488	ImGuiID NavNextActivateId; // Set by ActivateItemByID(), queued until next frame.
2489	ImGuiActivateFlags NavNextActivateFlags;
2490	ImGuiInputSource NavInputSource; // Keyboard or Gamepad mode? THIS CAN ONLY BE ImGuiInputSource_Keyboard or ImGuiInputSource_Mouse
2491	ImGuiSelectionUserData NavLastValidSelectionUserData; // Last valid data passed to SetNextItemSelectionUser(), or -1. For current window. Not reset when focusing an item that doesn't have selection data.
2492	ImS8 NavCursorHideFrames;
2493	//ImGuiID NavActivateInputId; // Removed in 1.89.4 (July 2023). This is now part of g.NavActivateId and sets g.NavActivateFlags |= ImGuiActivateFlags_PreferInput. See commit c9a53aa74, issue #5606.
2494
2495	// Navigation: Init & Move Requests
2496	bool NavAnyRequest; // ~~ NavMoveRequest || NavInitRequest this is to perform early out in ItemAdd()
2497	bool NavInitRequest; // Init request for appearing window to select first item
2498	bool NavInitRequestFromMove;
2499	ImGuiNavItemData NavInitResult; // Init request result (first item of the window, or one for which SetItemDefaultFocus() was called)
2500	bool NavMoveSubmitted; // Move request submitted, will process result on next NewFrame()
2501	bool NavMoveScoringItems; // Move request submitted, still scoring incoming items
2502	bool NavMoveForwardToNextFrame;
2503	ImGuiNavMoveFlags NavMoveFlags;
2504	ImGuiScrollFlags NavMoveScrollFlags;
2505	ImGuiKeyChord NavMoveKeyMods;
2506	ImGuiDir NavMoveDir; // Direction of the move request (left/right/up/down)
2507	ImGuiDir NavMoveDirForDebug;
2508	ImGuiDir NavMoveClipDir; // FIXME-NAV: Describe the purpose of this better. Might want to rename?
2509	ImRect NavScoringRect; // Rectangle used for scoring, in screen space. Based of window->NavRectRel[], modified for directional navigation scoring.
2510	ImRect NavScoringNoClipRect; // Some nav operations (such as PageUp/PageDown) enforce a region which clipper will attempt to always keep submitted
2511	int NavScoringDebugCount; // Metrics for debugging
2512	int NavTabbingDir; // Generally -1 or +1, 0 when tabbing without a nav id
2513	int NavTabbingCounter; // >0 when counting items for tabbing
2514	ImGuiNavItemData NavMoveResultLocal; // Best move request candidate within NavWindow
2515	ImGuiNavItemData NavMoveResultLocalVisible; // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)
2516	ImGuiNavItemData NavMoveResultOther; // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)
2517	ImGuiNavItemData NavTabbingResultFirst; // First tabbing request candidate within NavWindow and flattened hierarchy
2518
2519	// Navigation: record of last move request
2520	ImGuiID NavJustMovedFromFocusScopeId; // Just navigated from this focus scope id (result of a successfully MoveRequest).
2521	ImGuiID NavJustMovedToId; // Just navigated to this id (result of a successfully MoveRequest).
2522	ImGuiID NavJustMovedToFocusScopeId; // Just navigated to this focus scope id (result of a successfully MoveRequest).
2523	ImGuiKeyChord NavJustMovedToKeyMods;
2524	bool NavJustMovedToIsTabbing; // Copy of ImGuiNavMoveFlags_IsTabbing. Maybe we should store whole flags.
2525	bool NavJustMovedToHasSelectionData; // Copy of move result's ItemFlags & ImGuiItemFlags_HasSelectionUserData). Maybe we should just store ImGuiNavItemData.
2526
2527	// Navigation: Windowing (CTRL+TAB for list, or Menu button + keys or directional pads to move/resize)
2528	bool ConfigNavWindowingWithGamepad; // = true. Enable CTRL+TAB by holding ImGuiKey_GamepadFaceLeft (== ImGuiKey_NavGamepadMenu). When false, the button may still be used to toggle Menu layer.
2529	ImGuiKeyChord ConfigNavWindowingKeyNext; // = ImGuiMod_Ctrl | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiKey_Tab on OS X). For reconfiguration (see #4828)
2530	ImGuiKeyChord ConfigNavWindowingKeyPrev; // = ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Tab (or ImGuiMod_Super | ImGuiMod_Shift | ImGuiKey_Tab on OS X)
2531	ImGuiWindow* NavWindowingTarget; // Target window when doing CTRL+Tab (or Pad Menu + FocusPrev/Next), this window is temporarily displayed top-most!
2532	ImGuiWindow* NavWindowingTargetAnim; // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f, so the fade-out can stay on it.
2533	ImGuiWindow* NavWindowingListWindow; // Internal window actually listing the CTRL+Tab contents
2534	float NavWindowingTimer;
2535	float NavWindowingHighlightAlpha;
2536	ImGuiInputSource NavWindowingInputSource;
2537	bool NavWindowingToggleLayer; // Set while Alt or GamepadMenu is held, may be cleared by other operations, and processed when releasing the key.
2538	ImGuiKey NavWindowingToggleKey; // Keyboard/gamepad key used when toggling to menu layer.
2539	ImVec2 NavWindowingAccumDeltaPos;
2540	ImVec2 NavWindowingAccumDeltaSize;
2541
2542	// Render
2543	float DimBgRatio; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)
2544
2545	// Drag and Drop
2546	bool DragDropActive;
2547	bool DragDropWithinSource; // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag source.
2548	bool DragDropWithinTarget; // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag target.
2549	ImGuiDragDropFlags DragDropSourceFlags;
2550	int DragDropSourceFrameCount;
2551	int DragDropMouseButton;
2552	ImGuiPayload DragDropPayload;
2553	ImRect DragDropTargetRect; // Store rectangle of current target candidate (we favor small targets when overlapping)
2554	ImRect DragDropTargetClipRect; // Store ClipRect at the time of item's drawing
2555	ImGuiID DragDropTargetId;
2556	ImGuiDragDropFlags DragDropAcceptFlags;
2557	float DragDropAcceptIdCurrRectSurface; // Target item surface (we resolve overlapping targets by prioritizing the smaller surface)
2558	ImGuiID DragDropAcceptIdCurr; // Target item id (set at the time of accepting the payload)
2559	ImGuiID DragDropAcceptIdPrev; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
2560	int DragDropAcceptFrameCount; // Last time a target expressed a desire to accept the source
2561	ImGuiID DragDropHoldJustPressedId; // Set when holding a payload just made ButtonBehavior() return a press.
2562	ImVector<unsigned char> DragDropPayloadBufHeap; // We don't expose the ImVector<> directly, ImGuiPayload only holds pointer+size
2563	unsigned char DragDropPayloadBufLocal[16]; // Local buffer for small payloads
2564
2565	// Clipper
2566	int ClipperTempDataStacked;
2567	ImVector<ImGuiListClipperData> ClipperTempData;
2568
2569	// Tables
2570	ImGuiTable* CurrentTable;
2571	ImGuiID DebugBreakInTable; // Set to break in BeginTable() call.
2572	int TablesTempDataStacked; // Temporary table data size (because we leave previous instances undestructed, we generally don't use TablesTempData.Size)
2573	ImVector<ImGuiTableTempData> TablesTempData; // Temporary table data (buffers reused/shared across instances, support nesting)
2574	ImPool<ImGuiTable> Tables; // Persistent table data
2575	ImVector<float> TablesLastTimeActive; // Last used timestamp of each tables (SOA, for efficient GC)
2576	ImVector<ImDrawChannel> DrawChannelsTempMergeBuffer;
2577
2578	// Tab bars
2579	ImGuiTabBar* CurrentTabBar;
2580	ImPool<ImGuiTabBar> TabBars;
2581	ImVector<ImGuiPtrOrIndex> CurrentTabBarStack;
2582	ImVector<ImGuiShrinkWidthItem> ShrinkWidthBuffer;
2583
2584	// Multi-Select state
2585	ImGuiBoxSelectState BoxSelectState;
2586	ImGuiMultiSelectTempData* CurrentMultiSelect;
2587	int MultiSelectTempDataStacked; // Temporary multi-select data size (because we leave previous instances undestructed, we generally don't use MultiSelectTempData.Size)
2588	ImVector<ImGuiMultiSelectTempData> MultiSelectTempData;
2589	ImPool<ImGuiMultiSelectState> MultiSelectStorage;
2590
2591	// Hover Delay system
2592	ImGuiID HoverItemDelayId;
2593	ImGuiID HoverItemDelayIdPreviousFrame;
2594	float HoverItemDelayTimer; // Currently used by IsItemHovered()
2595	float HoverItemDelayClearTimer; // Currently used by IsItemHovered(): grace time before g.TooltipHoverTimer gets cleared.
2596	ImGuiID HoverItemUnlockedStationaryId; // Mouse has once been stationary on this item. Only reset after departing the item.
2597	ImGuiID HoverWindowUnlockedStationaryId; // Mouse has once been stationary on this window. Only reset after departing the window.
2598
2599	// Mouse state
2600	ImGuiMouseCursor MouseCursor;
2601	float MouseStationaryTimer; // Time the mouse has been stationary (with some loose heuristic)
2602	ImVec2 MouseLastValidPos;
2603
2604	// Widget state
2605	ImGuiInputTextState InputTextState;
2606	ImGuiInputTextDeactivatedState InputTextDeactivatedState;
2607	ImFontBaked InputTextPasswordFontBackupBaked;
2608	ImFontFlags InputTextPasswordFontBackupFlags;
2609	ImGuiID TempInputId; // Temporary text input when CTRL+clicking on a slider, etc.
2610	ImGuiDataTypeStorage DataTypeZeroValue; // 0 for all data types
2611	int BeginMenuDepth;
2612	int BeginComboDepth;
2613	ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets
2614	ImGuiID ColorEditCurrentID; // Set temporarily while inside of the parent-most ColorEdit4/ColorPicker4 (because they call each others).
2615	ImGuiID ColorEditSavedID; // ID we are saving/restoring HS for
2616	float ColorEditSavedHue; // Backup of last Hue associated to LastColor, so we can restore Hue in lossy RGB<>HSV round trips
2617	float ColorEditSavedSat; // Backup of last Saturation associated to LastColor, so we can restore Saturation in lossy RGB<>HSV round trips
2618	ImU32 ColorEditSavedColor; // RGB value with alpha set to 0.
2619	ImVec4 ColorPickerRef; // Initial/reference color at the time of opening the color picker.
2620	ImGuiComboPreviewData ComboPreviewData;
2621	ImRect WindowResizeBorderExpectedRect; // Expected border rect, switch to relative edit if moving
2622	bool WindowResizeRelativeMode;
2623	short ScrollbarSeekMode; // 0: scroll to clicked location, -1/+1: prev/next page.
2624	float ScrollbarClickDeltaToGrabCenter; // When scrolling to mouse location: distance between mouse and center of grab box, normalized in parent space.
2625	float SliderGrabClickOffset;
2626	float SliderCurrentAccum; // Accumulated slider delta when using navigation controls.
2627	bool SliderCurrentAccumDirty; // Has the accumulated slider delta changed since last time we tried to apply it?
2628	bool DragCurrentAccumDirty;
2629	float DragCurrentAccum; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
2630	float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
2631	float DisabledAlphaBackup; // Backup for style.Alpha for BeginDisabled()
2632	short DisabledStackSize;
2633	short TooltipOverrideCount;
2634	ImGuiWindow* TooltipPreviousWindow; // Window of last tooltip submitted during the frame
2635	ImVector<char> ClipboardHandlerData; // If no custom clipboard handler is defined
2636	ImVector<ImGuiID> MenusIdSubmittedThisFrame; // A list of menu IDs that were rendered at least once
2637	ImGuiTypingSelectState TypingSelectState; // State for GetTypingSelectRequest()
2638
2639	// Platform support
2640	ImGuiPlatformImeData PlatformImeData; // Data updated by current frame. Will be applied at end of the frame. For some backends, this is required to have WantVisible=true in order to receive text message.
2641	ImGuiPlatformImeData PlatformImeDataPrev; // Previous frame data. When changed we call the platform_io.Platform_SetImeDataFn() handler.
2642
2643	// Extensions
2644	// FIXME: We could provide an API to register one slot in an array held in ImGuiContext?
2645	ImVector<ImTextureData*> UserTextures; // List of textures created/managed by user or third-party extension. Automatically appended into platform_io.Textures[].
2646	ImGuiDockContext DockContext;
2647	void (*DockNodeWindowMenuHandler)(ImGuiContext* ctx, ImGuiDockNode* node, ImGuiTabBar* tab_bar);
2648
2649	// Settings
2650	bool SettingsLoaded;
2651	float SettingsDirtyTimer; // Save .ini Settings to memory when time reaches zero
2652	ImGuiTextBuffer SettingsIniData; // In memory .ini settings
2653	ImVector<ImGuiSettingsHandler> SettingsHandlers; // List of .ini settings handlers
2654	ImChunkStream<ImGuiWindowSettings> SettingsWindows; // ImGuiWindow .ini settings entries
2655	ImChunkStream<ImGuiTableSettings> SettingsTables; // ImGuiTable .ini settings entries
2656	ImVector<ImGuiContextHook> Hooks; // Hooks for extensions (e.g. test engine)
2657	ImGuiID HookIdNext; // Next available HookId
2658
2659	// Localization
2660	const char* LocalizationTable[ImGuiLocKey_COUNT];
2661
2662	// Capture/Logging
2663	bool LogEnabled; // Currently capturing
2664	ImGuiLogFlags LogFlags; // Capture flags/type
2665	ImGuiWindow* LogWindow;
2666	ImFileHandle LogFile; // If != NULL log to stdout/ file
2667	ImGuiTextBuffer LogBuffer; // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
2668	const char* LogNextPrefix;
2669	const char* LogNextSuffix;
2670	float LogLinePosY;
2671	bool LogLineFirstItem;
2672	int LogDepthRef;
2673	int LogDepthToExpand;
2674	int LogDepthToExpandDefault; // Default/stored value for LogDepthMaxExpand if not specified in the LogXXX function call.
2675
2676	// Error Handling
2677	ImGuiErrorCallback ErrorCallback; // = NULL. May be exposed in public API eventually.
2678	void* ErrorCallbackUserData; // = NULL
2679	ImVec2 ErrorTooltipLockedPos;
2680	bool ErrorFirst;
2681	int ErrorCountCurrentFrame; // [Internal] Number of errors submitted this frame.
2682	ImGuiErrorRecoveryState StackSizesInNewFrame; // [Internal]
2683	ImGuiErrorRecoveryState*StackSizesInBeginForCurrentWindow; // [Internal]
2684
2685	// Debug Tools
2686	// (some of the highly frequently used data are interleaved in other structures above: DebugBreakXXX fields, DebugHookIdInfo, DebugLocateId etc.)
2687	int DebugDrawIdConflictsCount; // Locked count (preserved when holding CTRL)
2688	ImGuiDebugLogFlags DebugLogFlags;
2689	ImGuiTextBuffer DebugLogBuf;
2690	ImGuiTextIndex DebugLogIndex;
2691	int DebugLogSkippedErrors;
2692	ImGuiDebugLogFlags DebugLogAutoDisableFlags;
2693	ImU8 DebugLogAutoDisableFrames;
2694	ImU8 DebugLocateFrames; // For DebugLocateItemOnHover(). This is used together with DebugLocateId which is in a hot/cached spot above.
2695	bool DebugBreakInLocateId; // Debug break in ItemAdd() call for g.DebugLocateId.
2696	ImGuiKeyChord DebugBreakKeyChord; // = ImGuiKey_Pause
2697	ImS8 DebugBeginReturnValueCullDepth; // Cycle between 0..9 then wrap around.
2698	bool DebugItemPickerActive; // Item picker is active (started with DebugStartItemPicker())
2699	ImU8 DebugItemPickerMouseButton;
2700	ImGuiID DebugItemPickerBreakId; // Will call IM_DEBUG_BREAK() when encountering this ID
2701	float DebugFlashStyleColorTime;
2702	ImVec4 DebugFlashStyleColorBackup;
2703	ImGuiMetricsConfig DebugMetricsConfig;
2704	ImGuiIDStackTool DebugIDStackTool;
2705	ImGuiDebugAllocInfo DebugAllocInfo;
2706	ImGuiDockNode* DebugHoveredDockNode; // Hovered dock node.
2707	#if defined(IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS) && !defined(IMGUI_DISABLE_DEBUG_TOOLS)
2708	ImGuiStorage DebugDrawIdConflictsAliveCount;
2709	ImGuiStorage DebugDrawIdConflictsHighlightSet;
2710	#endif
2711
2712	// Misc
2713	float FramerateSecPerFrame[60]; // Calculate estimate of framerate for user over the last 60 frames..
2714	int FramerateSecPerFrameIdx;
2715	int FramerateSecPerFrameCount;
2716	float FramerateSecPerFrameAccum;
2717	int WantCaptureMouseNextFrame; // Explicit capture override via SetNextFrameWantCaptureMouse()/SetNextFrameWantCaptureKeyboard(). Default to -1.
2718	int WantCaptureKeyboardNextFrame; // "
2719	int WantTextInputNextFrame; // Copied in EndFrame() from g.PlatformImeData.WantTextInput. Needs to be set for some backends (SDL3) to emit character inputs.
2720	ImVector<char> TempBuffer; // Temporary text buffer
2721	char TempKeychordName[64];
2722
2723	ImGuiContext(ImFontAtlas* shared_font_atlas);
2724	};
2725
2726	//-----------------------------------------------------------------------------
2727	// [SECTION] ImGuiWindowTempData, ImGuiWindow
2728	//-----------------------------------------------------------------------------
2729
2730	// Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.
2731	// (That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered..)
2732	// (This doesn't need a constructor because we zero-clear it as part of ImGuiWindow and all frame-temporary data are setup on Begin)
2733	struct IMGUI_API ImGuiWindowTempData
2734	{
2735	// Layout
2736	ImVec2 CursorPos; // Current emitting position, in absolute coordinates.
2737	ImVec2 CursorPosPrevLine;
2738	ImVec2 CursorStartPos; // Initial position after Begin(), generally ~ window position + WindowPadding.
2739	ImVec2 CursorMaxPos; // Used to implicitly calculate ContentSize at the beginning of next frame, for scrolling range and auto-resize. Always growing during the frame.
2740	ImVec2 IdealMaxPos; // Used to implicitly calculate ContentSizeIdeal at the beginning of next frame, for auto-resize only. Always growing during the frame.
2741	ImVec2 CurrLineSize;
2742	ImVec2 PrevLineSize;
2743	float CurrLineTextBaseOffset; // Baseline offset (0.0f by default on a new line, generally == style.FramePadding.y when a framed item has been added).
2744	float PrevLineTextBaseOffset;
2745	bool IsSameLine;
2746	bool IsSetPos;
2747	ImVec1 Indent; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
2748	ImVec1 ColumnsOffset; // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
2749	ImVec1 GroupOffset;
2750	ImVec2 CursorStartPosLossyness;// Record the loss of precision of CursorStartPos due to really large scrolling amount. This is used by clipper to compensate and fix the most common use case of large scroll area.
2751
2752	// Keyboard/Gamepad navigation
2753	ImGuiNavLayer NavLayerCurrent; // Current layer, 0..31 (we currently only use 0..1)
2754	short NavLayersActiveMask; // Which layers have been written to (result from previous frame)
2755	short NavLayersActiveMaskNext;// Which layers have been written to (accumulator for current frame)
2756	bool NavIsScrollPushableX; // Set when current work location may be scrolled horizontally when moving left / right. This is generally always true UNLESS within a column.
2757	bool NavHideHighlightOneFrame;
2758	bool NavWindowHasScrollY; // Set per window when scrolling can be used (== ScrollMax.y > 0.0f)
2759
2760	// Miscellaneous
2761	bool MenuBarAppending; // FIXME: Remove this
2762	ImVec2 MenuBarOffset; // MenuBarOffset.x is sort of equivalent of a per-layer CursorPos.x, saved/restored as we switch to the menu bar. The only situation when MenuBarOffset.y is > 0 if when (SafeAreaPadding.y > FramePadding.y), often used on TVs.
2763	ImGuiMenuColumns MenuColumns; // Simplified columns storage for menu items measurement
2764	int TreeDepth; // Current tree depth.
2765	ImU32 TreeHasStackDataDepthMask; // Store whether given depth has ImGuiTreeNodeStackData data. Could be turned into a ImU64 if necessary.
2766	ImU32 TreeRecordsClippedNodesY2Mask; // Store whether we should keep recording Y2. Cleared when passing clip max. Equivalent TreeHasStackDataDepthMask value should always be set.
2767	ImVector<ImGuiWindow*> ChildWindows;
2768	ImGuiStorage* StateStorage; // Current persistent per-window storage (store e.g. tree node open/close state)
2769	ImGuiOldColumns* CurrentColumns; // Current columns set
2770	int CurrentTableIdx; // Current table index (into g.Tables)
2771	ImGuiLayoutType LayoutType;
2772	ImGuiLayoutType ParentLayoutType; // Layout type of parent window at the time of Begin()
2773	ImU32 ModalDimBgColor;
2774
2775	// Status flags
2776	ImGuiItemStatusFlags WindowItemStatusFlags;
2777	ImGuiItemStatusFlags ChildItemStatusFlags;
2778	ImGuiItemStatusFlags DockTabItemStatusFlags;
2779	ImRect DockTabItemRect;
2780
2781	// Local parameters stacks
2782	// We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
2783	float ItemWidth; // Current item width (>0.0: width in pixels, <0.0: align xx pixels to the right of window).
2784	float TextWrapPos; // Current text wrap pos.
2785	ImVector<float> ItemWidthStack; // Store item widths to restore (attention: .back() is not == ItemWidth)
2786	ImVector<float> TextWrapPosStack; // Store text wrap pos to restore (attention: .back() is not == TextWrapPos)
2787	};
2788
2789	// Storage for one window
2790	struct IMGUI_API ImGuiWindow
2791	{
2792	ImGuiContext* Ctx; // Parent UI context (needs to be set explicitly by parent).
2793	char* Name; // Window name, owned by the window.
2794	ImGuiID ID; // == ImHashStr(Name)
2795	ImGuiWindowFlags Flags, FlagsPreviousFrame; // See enum ImGuiWindowFlags_
2796	ImGuiChildFlags ChildFlags; // Set when window is a child window. See enum ImGuiChildFlags_
2797	ImGuiWindowClass WindowClass; // Advanced users only. Set with SetNextWindowClass()
2798	ImGuiViewportP* Viewport; // Always set in Begin(). Inactive windows may have a NULL value here if their viewport was discarded.
2799	ImGuiID ViewportId; // We backup the viewport id (since the viewport may disappear or never be created if the window is inactive)
2800	ImVec2 ViewportPos; // We backup the viewport position (since the viewport may disappear or never be created if the window is inactive)
2801	int ViewportAllowPlatformMonitorExtend; // Reset to -1 every frame (index is guaranteed to be valid between NewFrame..EndFrame), only used in the Appearing frame of a tooltip/popup to enforce clamping to a given monitor
2802	ImVec2 Pos; // Position (always rounded-up to nearest pixel)
2803	ImVec2 Size; // Current size (==SizeFull or collapsed title bar size)
2804	ImVec2 SizeFull; // Size when non collapsed
2805	ImVec2 ContentSize; // Size of contents/scrollable client area (calculated from the extents reach of the cursor) from previous frame. Does not include window decoration or window padding.
2806	ImVec2 ContentSizeIdeal;
2807	ImVec2 ContentSizeExplicit; // Size of contents/scrollable client area explicitly request by the user via SetNextWindowContentSize().
2808	ImVec2 WindowPadding; // Window padding at the time of Begin().
2809	float WindowRounding; // Window rounding at the time of Begin(). May be clamped lower to avoid rendering artifacts with title bar, menu bar etc.
2810	float WindowBorderSize; // Window border size at the time of Begin().
2811	float TitleBarHeight, MenuBarHeight; // Note that those used to be function before 2024/05/28. If you have old code calling TitleBarHeight() you can change it to TitleBarHeight.
2812	float DecoOuterSizeX1, DecoOuterSizeY1; // Left/Up offsets. Sum of non-scrolling outer decorations (X1 generally == 0.0f. Y1 generally = TitleBarHeight + MenuBarHeight). Locked during Begin().
2813	float DecoOuterSizeX2, DecoOuterSizeY2; // Right/Down offsets (X2 generally == ScrollbarSize.x, Y2 == ScrollbarSizes.y).
2814	float DecoInnerSizeX1, DecoInnerSizeY1; // Applied AFTER/OVER InnerRect. Specialized for Tables as they use specialized form of clipping and frozen rows/columns are inside InnerRect (and not part of regular decoration sizes).
2815	int NameBufLen; // Size of buffer storing Name. May be larger than strlen(Name)!
2816	ImGuiID MoveId; // == window->GetID("#MOVE")
2817	ImGuiID TabId; // == window->GetID("#TAB")
2818	ImGuiID ChildId; // ID of corresponding item in parent window (for navigation to return from child window to parent window)
2819	ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
2820	ImVec2 Scroll;
2821	ImVec2 ScrollMax;
2822	ImVec2 ScrollTarget; // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
2823	ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
2824	ImVec2 ScrollTargetEdgeSnapDist; // 0.0f = no snapping, >0.0f snapping threshold
2825	ImVec2 ScrollbarSizes; // Size taken by each scrollbars on their smaller axis. Pay attention! ScrollbarSizes.x == width of the vertical scrollbar, ScrollbarSizes.y = height of the horizontal scrollbar.
2826	bool ScrollbarX, ScrollbarY; // Are scrollbars visible?
2827	bool ScrollbarXStabilizeEnabled; // Was ScrollbarX previously auto-stabilized?
2828	ImU8 ScrollbarXStabilizeToggledHistory; // Used to stabilize scrollbar visibility in case of feedback loops
2829	bool ViewportOwned;
2830	bool Active; // Set to true on Begin(), unless Collapsed
2831	bool WasActive;
2832	bool WriteAccessed; // Set to true when any widget access the current window
2833	bool Collapsed; // Set when collapsing window to become only title-bar
2834	bool WantCollapseToggle;
2835	bool SkipItems; // Set when items can safely be all clipped (e.g. window not visible or collapsed)
2836	bool SkipRefresh; // [EXPERIMENTAL] Reuse previous frame drawn contents, Begin() returns false.
2837	bool Appearing; // Set during the frame where the window is appearing (or re-appearing)
2838	bool Hidden; // Do not display (== HiddenFrames*** > 0)
2839	bool IsFallbackWindow; // Set on the "Debug##Default" window.
2840	bool IsExplicitChild; // Set when passed _ChildWindow, left to false by BeginDocked()
2841	bool HasCloseButton; // Set when the window has a close button (p_open != NULL)
2842	signed char ResizeBorderHovered; // Current border being hovered for resize (-1: none, otherwise 0-3)
2843	signed char ResizeBorderHeld; // Current border being held for resize (-1: none, otherwise 0-3)
2844	short BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
2845	short BeginCountPreviousFrame; // Number of Begin() during the previous frame
2846	short BeginOrderWithinParent; // Begin() order within immediate parent window, if we are a child window. Otherwise 0.
2847	short BeginOrderWithinContext; // Begin() order within entire imgui context. This is mostly used for debugging submission order related issues.
2848	short FocusOrder; // Order within WindowsFocusOrder[], altered when windows are focused.
2849	ImS8 AutoFitFramesX, AutoFitFramesY;
2850	bool AutoFitOnlyGrows;
2851	ImGuiDir AutoPosLastDirection;
2852	ImS8 HiddenFramesCanSkipItems; // Hide the window for N frames
2853	ImS8 HiddenFramesCannotSkipItems; // Hide the window for N frames while allowing items to be submitted so we can measure their size
2854	ImS8 HiddenFramesForRenderOnly; // Hide the window until frame N at Render() time only
2855	ImS8 DisableInputsFrames; // Disable window interactions for N frames
2856	ImGuiCond SetWindowPosAllowFlags : 8; // store acceptable condition flags for SetNextWindowPos() use.
2857	ImGuiCond SetWindowSizeAllowFlags : 8; // store acceptable condition flags for SetNextWindowSize() use.
2858	ImGuiCond SetWindowCollapsedAllowFlags : 8; // store acceptable condition flags for SetNextWindowCollapsed() use.
2859	ImGuiCond SetWindowDockAllowFlags : 8; // store acceptable condition flags for SetNextWindowDock() use.
2860	ImVec2 SetWindowPosVal; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
2861	ImVec2 SetWindowPosPivot; // store window pivot for positioning. ImVec2(0, 0) when positioning from top-left corner; ImVec2(0.5f, 0.5f) for centering; ImVec2(1, 1) for bottom right.
2862
2863	ImVector<ImGuiID> IDStack; // ID stack. ID are hashes seeded with the value at the top of the stack. (In theory this should be in the TempData structure)
2864	ImGuiWindowTempData DC; // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name.
2865
2866	// The best way to understand what those rectangles are is to use the 'Metrics->Tools->Show Windows Rectangles' viewer.
2867	// The main 'OuterRect', omitted as a field, is window->Rect().
2868	ImRect OuterRectClipped; // == Window->Rect() just after setup in Begin(). == window->Rect() for root window.
2869	ImRect InnerRect; // Inner rectangle (omit title bar, menu bar, scroll bar)
2870	ImRect InnerClipRect; // == InnerRect shrunk by WindowPadding*0.5f on each side, clipped within viewport or parent clip rect.
2871	ImRect WorkRect; // Initially covers the whole scrolling region. Reduced by containers e.g columns/tables when active. Shrunk by WindowPadding*1.0f on each side. This is meant to replace ContentRegionRect over time (from 1.71+ onward).
2872	ImRect ParentWorkRect; // Backup of WorkRect before entering a container such as columns/tables. Used by e.g. SpanAllColumns functions to easily access. Stacked containers are responsible for maintaining this. // FIXME-WORKRECT: Could be a stack?
2873	ImRect ClipRect; // Current clipping/scissoring rectangle, evolve as we are using PushClipRect(), etc. == DrawList->clip_rect_stack.back().
2874	ImRect ContentRegionRect; // FIXME: This is currently confusing/misleading. It is essentially WorkRect but not handling of scrolling. We currently rely on it as right/bottom aligned sizing operation need some size to rely on.
2875	ImVec2ih HitTestHoleSize; // Define an optional rectangular hole where mouse will pass-through the window.
2876	ImVec2ih HitTestHoleOffset;
2877
2878	int LastFrameActive; // Last frame number the window was Active.
2879	int LastFrameJustFocused; // Last frame number the window was made Focused.
2880	float LastTimeActive; // Last timestamp the window was Active (using float as we don't need high precision there)
2881	float ItemWidthDefault;
2882	ImGuiStorage StateStorage;
2883	ImVector<ImGuiOldColumns> ColumnsStorage;
2884	float FontWindowScale; // User scale multiplier per-window, via SetWindowFontScale()
2885	float FontWindowScaleParents;
2886	float FontRefSize; // This is a copy of window->CalcFontSize() at the time of Begin(), trying to phase out CalcFontSize() especially as it may be called on non-current window.
2887	int SettingsOffset; // Offset into SettingsWindows[] (offsets are always valid as we only grow the array from the back)
2888
2889	ImDrawList* DrawList; // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)
2890	ImDrawList DrawListInst;
2891	ImGuiWindow* ParentWindow; // If we are a child _or_ popup _or_ docked window, this is pointing to our parent. Otherwise NULL.
2892	ImGuiWindow* ParentWindowInBeginStack;
2893	ImGuiWindow* RootWindow; // Point to ourself or first ancestor that is not a child window. Doesn't cross through popups/dock nodes.
2894	ImGuiWindow* RootWindowPopupTree; // Point to ourself or first ancestor that is not a child window. Cross through popups parent<>child.
2895	ImGuiWindow* RootWindowDockTree; // Point to ourself or first ancestor that is not a child window. Cross through dock nodes.
2896	ImGuiWindow* RootWindowForTitleBarHighlight; // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
2897	ImGuiWindow* RootWindowForNav; // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
2898	ImGuiWindow* ParentWindowForFocusRoute; // Set to manual link a window to its logical parent so that Shortcut() chain are honoerd (e.g. Tool linked to Document)
2899
2900	ImGuiWindow* NavLastChildNavWindow; // When going to the menu bar, we remember the child window we came from. (This could probably be made implicit if we kept g.Windows sorted by last focused including child window.)
2901	ImGuiID NavLastIds[ImGuiNavLayer_COUNT]; // Last known NavId for this window, per layer (0/1)
2902	ImRect NavRectRel[ImGuiNavLayer_COUNT]; // Reference rectangle, in window relative space
2903	ImVec2 NavPreferredScoringPosRel[ImGuiNavLayer_COUNT]; // Preferred X/Y position updated when moving on a given axis, reset to FLT_MAX.
2904	ImGuiID NavRootFocusScopeId; // Focus Scope ID at the time of Begin()
2905
2906	int MemoryDrawListIdxCapacity; // Backup of last idx/vtx count, so when waking up the window we can preallocate and avoid iterative alloc/copy
2907	int MemoryDrawListVtxCapacity;
2908	bool MemoryCompacted; // Set when window extraneous data have been garbage collected
2909
2910	// Docking
2911	bool DockIsActive :1; // When docking artifacts are actually visible. When this is set, DockNode is guaranteed to be != NULL. ~~ (DockNode != NULL) && (DockNode->Windows.Size > 1).
2912	bool DockNodeIsVisible :1;
2913	bool DockTabIsVisible :1; // Is our window visible this frame? ~~ is the corresponding tab selected?
2914	bool DockTabWantClose :1;
2915	short DockOrder; // Order of the last time the window was visible within its DockNode. This is used to reorder windows that are reappearing on the same frame. Same value between windows that were active and windows that were none are possible.
2916	ImGuiWindowDockStyle DockStyle;
2917	ImGuiDockNode* DockNode; // Which node are we docked into. Important: Prefer testing DockIsActive in many cases as this will still be set when the dock node is hidden.
2918	ImGuiDockNode* DockNodeAsHost; // Which node are we owning (for parent windows)
2919	ImGuiID DockId; // Backup of last valid DockNode->ID, so single window remember their dock node id even when they are not bound any more
2920
2921	public:
2922	ImGuiWindow(ImGuiContext* context, const char* name);
2923	~ImGuiWindow();
2924
2925	ImGuiID GetID(const char* str, const char* str_end = NULL);
2926	ImGuiID GetID(const void* ptr);
2927	ImGuiID GetID(int n);
2928	ImGuiID GetIDFromPos(const ImVec2& p_abs);
2929	ImGuiID GetIDFromRectangle(const ImRect& r_abs);
2930
2931	// We don't use g.FontSize because the window may be != g.CurrentWindow.
2932	ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
2933	ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight)); }
2934	ImRect MenuBarRect() const { float y1 = Pos.y + TitleBarHeight; return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight); }
2935
2936	// [Obsolete] ImGuiWindow::CalcFontSize() was removed in 1.92.x because error-prone/misleading. You can use window->FontRefSize for a copy of g.FontSize at the time of the last Begin() call for this window.
2937	//float CalcFontSize() const { ImGuiContext& g = *Ctx; return g.FontSizeBase * FontWindowScale * FontDpiScale * FontWindowScaleParents;
2938	};
2939
2940	//-----------------------------------------------------------------------------
2941	// [SECTION] Tab bar, Tab item support
2942	//-----------------------------------------------------------------------------
2943
2944	// Extend ImGuiTabBarFlags_
2945	enum ImGuiTabBarFlagsPrivate_
2946	{
2947	ImGuiTabBarFlags_DockNode = 1 << 20, // Part of a dock node [we don't use this in the master branch but it facilitate branch syncing to keep this around]
2948	ImGuiTabBarFlags_IsFocused = 1 << 21,
2949	ImGuiTabBarFlags_SaveSettings = 1 << 22, // FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs
2950	};
2951
2952	// Extend ImGuiTabItemFlags_
2953	enum ImGuiTabItemFlagsPrivate_
2954	{
2955	ImGuiTabItemFlags_SectionMask_ = ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing,
2956	ImGuiTabItemFlags_NoCloseButton = 1 << 20, // Track whether p_open was set or not (we'll need this info on the next frame to recompute ContentWidth during layout)
2957	ImGuiTabItemFlags_Button = 1 << 21, // Used by TabItemButton, change the tab item behavior to mimic a button
2958	ImGuiTabItemFlags_Invisible = 1 << 22, // To reserve space e.g. with ImGuiTabItemFlags_Leading
2959	ImGuiTabItemFlags_Unsorted = 1 << 23, // [Docking] Trailing tabs with the _Unsorted flag will be sorted based on the DockOrder of their Window.
2960	};
2961
2962	// Storage for one active tab item (sizeof() 48 bytes)
2963	struct ImGuiTabItem
2964	{
2965	ImGuiID ID;
2966	ImGuiTabItemFlags Flags;
2967	ImGuiWindow* Window; // When TabItem is part of a DockNode's TabBar, we hold on to a window.
2968	int LastFrameVisible;
2969	int LastFrameSelected; // This allows us to infer an ordered list of the last activated tabs with little maintenance
2970	float Offset; // Position relative to beginning of tab
2971	float Width; // Width currently displayed
2972	float ContentWidth; // Width of label + padding, stored during BeginTabItem() call (misnamed as "Content" would normally imply width of label only)
2973	float RequestedWidth; // Width optionally requested by caller, -1.0f is unused
2974	ImS32 NameOffset; // When Window==NULL, offset to name within parent ImGuiTabBar::TabsNames
2975	ImS16 BeginOrder; // BeginTabItem() order, used to re-order tabs after toggling ImGuiTabBarFlags_Reorderable
2976	ImS16 IndexDuringLayout; // Index only used during TabBarLayout(). Tabs gets reordered so 'Tabs[n].IndexDuringLayout == n' but may mismatch during additions.
2977	bool WantClose; // Marked as closed by SetTabItemClosed()
2978
2979	ImGuiTabItem() { memset(s: this, c: 0, n: sizeof(*this)); LastFrameVisible = LastFrameSelected = -1; RequestedWidth = -1.0f; NameOffset = -1; BeginOrder = IndexDuringLayout = -1; }
2980	};
2981
2982	// Storage for a tab bar (sizeof() 160 bytes)
2983	struct IMGUI_API ImGuiTabBar
2984	{
2985	ImGuiWindow* Window;
2986	ImVector<ImGuiTabItem> Tabs;
2987	ImGuiTabBarFlags Flags;
2988	ImGuiID ID; // Zero for tab-bars used by docking
2989	ImGuiID SelectedTabId; // Selected tab/window
2990	ImGuiID NextSelectedTabId; // Next selected tab/window. Will also trigger a scrolling animation
2991	ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)
2992	int CurrFrameVisible;
2993	int PrevFrameVisible;
2994	ImRect BarRect;
2995	float BarRectPrevWidth; // Backup of previous width. When width change we enforce keep horizontal scroll on focused tab.
2996	float CurrTabsContentsHeight;
2997	float PrevTabsContentsHeight; // Record the height of contents submitted below the tab bar
2998	float WidthAllTabs; // Actual width of all tabs (locked during layout)
2999	float WidthAllTabsIdeal; // Ideal width if all tabs were visible and not clipped
3000	float ScrollingAnim;
3001	float ScrollingTarget;
3002	float ScrollingTargetDistToVisibility;
3003	float ScrollingSpeed;
3004	float ScrollingRectMinX;
3005	float ScrollingRectMaxX;
3006	float SeparatorMinX;
3007	float SeparatorMaxX;
3008	ImGuiID ReorderRequestTabId;
3009	ImS16 ReorderRequestOffset;
3010	ImS8 BeginCount;
3011	bool WantLayout;
3012	bool VisibleTabWasSubmitted;
3013	bool TabsAddedNew; // Set to true when a new tab item or button has been added to the tab bar during last frame
3014	bool ScrollButtonEnabled;
3015	ImS16 TabsActiveCount; // Number of tabs submitted this frame.
3016	ImS16 LastTabItemIdx; // Index of last BeginTabItem() tab for use by EndTabItem()
3017	float ItemSpacingY;
3018	ImVec2 FramePadding; // style.FramePadding locked at the time of BeginTabBar()
3019	ImVec2 BackupCursorPos;
3020	ImGuiTextBuffer TabsNames; // For non-docking tab bar we re-append names in a contiguous buffer.
3021
3022	ImGuiTabBar();
3023	};
3024
3025	//-----------------------------------------------------------------------------
3026	// [SECTION] Table support
3027	//-----------------------------------------------------------------------------
3028
3029	#define IM_COL32_DISABLE IM_COL32(0,0,0,1) // Special sentinel code which cannot be used as a regular color.
3030	#define IMGUI_TABLE_MAX_COLUMNS 512 // Arbitrary "safety" maximum, may be lifted in the future if needed. Must fit in ImGuiTableColumnIdx/ImGuiTableDrawChannelIdx.
3031
3032	// [Internal] sizeof() ~ 112
3033	// We use the terminology "Enabled" to refer to a column that is not Hidden by user/api.
3034	// We use the terminology "Clipped" to refer to a column that is out of sight because of scrolling/clipping.
3035	// This is in contrast with some user-facing api such as IsItemVisible() / IsRectVisible() which use "Visible" to mean "not clipped".
3036	struct ImGuiTableColumn
3037	{
3038	ImGuiTableColumnFlags Flags; // Flags after some patching (not directly same as provided by user). See ImGuiTableColumnFlags_
3039	float WidthGiven; // Final/actual width visible == (MaxX - MinX), locked in TableUpdateLayout(). May be > WidthRequest to honor minimum width, may be < WidthRequest to honor shrinking columns down in tight space.
3040	float MinX; // Absolute positions
3041	float MaxX;
3042	float WidthRequest; // Master width absolute value when !(Flags & _WidthStretch). When Stretch this is derived every frame from StretchWeight in TableUpdateLayout()
3043	float WidthAuto; // Automatic width
3044	float WidthMax; // Maximum width (FIXME: overwritten by each instance)
3045	float StretchWeight; // Master width weight when (Flags & _WidthStretch). Often around ~1.0f initially.
3046	float InitStretchWeightOrWidth; // Value passed to TableSetupColumn(). For Width it is a content width (_without padding_).
3047	ImRect ClipRect; // Clipping rectangle for the column
3048	ImGuiID UserID; // Optional, value passed to TableSetupColumn()
3049	float WorkMinX; // Contents region min ~(MinX + CellPaddingX + CellSpacingX1) == cursor start position when entering column
3050	float WorkMaxX; // Contents region max ~(MaxX - CellPaddingX - CellSpacingX2)
3051	float ItemWidth; // Current item width for the column, preserved across rows
3052	float ContentMaxXFrozen; // Contents maximum position for frozen rows (apart from headers), from which we can infer content width.
3053	float ContentMaxXUnfrozen;
3054	float ContentMaxXHeadersUsed; // Contents maximum position for headers rows (regardless of freezing). TableHeader() automatically softclip itself + report ideal desired size, to avoid creating extraneous draw calls
3055	float ContentMaxXHeadersIdeal;
3056	ImS16 NameOffset; // Offset into parent ColumnsNames[]
3057	ImGuiTableColumnIdx DisplayOrder; // Index within Table's IndexToDisplayOrder[] (column may be reordered by users)
3058	ImGuiTableColumnIdx IndexWithinEnabledSet; // Index within enabled/visible set (<= IndexToDisplayOrder)
3059	ImGuiTableColumnIdx PrevEnabledColumn; // Index of prev enabled/visible column within Columns[], -1 if first enabled/visible column
3060	ImGuiTableColumnIdx NextEnabledColumn; // Index of next enabled/visible column within Columns[], -1 if last enabled/visible column
3061	ImGuiTableColumnIdx SortOrder; // Index of this column within sort specs, -1 if not sorting on this column, 0 for single-sort, may be >0 on multi-sort
3062	ImGuiTableDrawChannelIdx DrawChannelCurrent; // Index within DrawSplitter.Channels[]
3063	ImGuiTableDrawChannelIdx DrawChannelFrozen; // Draw channels for frozen rows (often headers)
3064	ImGuiTableDrawChannelIdx DrawChannelUnfrozen; // Draw channels for unfrozen rows
3065	bool IsEnabled; // IsUserEnabled && (Flags & ImGuiTableColumnFlags_Disabled) == 0
3066	bool IsUserEnabled; // Is the column not marked Hidden by the user? (unrelated to being off view, e.g. clipped by scrolling).
3067	bool IsUserEnabledNextFrame;
3068	bool IsVisibleX; // Is actually in view (e.g. overlapping the host window clipping rectangle, not scrolled).
3069	bool IsVisibleY;
3070	bool IsRequestOutput; // Return value for TableSetColumnIndex() / TableNextColumn(): whether we request user to output contents or not.
3071	bool IsSkipItems; // Do we want item submissions to this column to be completely ignored (no layout will happen).
3072	bool IsPreserveWidthAuto;
3073	ImS8 NavLayerCurrent; // ImGuiNavLayer in 1 byte
3074	ImU8 AutoFitQueue; // Queue of 8 values for the next 8 frames to request auto-fit
3075	ImU8 CannotSkipItemsQueue; // Queue of 8 values for the next 8 frames to disable Clipped/SkipItem
3076	ImU8 SortDirection : 2; // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending
3077	ImU8 SortDirectionsAvailCount : 2; // Number of available sort directions (0 to 3)
3078	ImU8 SortDirectionsAvailMask : 4; // Mask of available sort directions (1-bit each)
3079	ImU8 SortDirectionsAvailList; // Ordered list of available sort directions (2-bits each, total 8-bits)
3080
3081	ImGuiTableColumn()
3082	{
3083	memset(s: this, c: 0, n: sizeof(*this));
3084	StretchWeight = WidthRequest = -1.0f;
3085	NameOffset = -1;
3086	DisplayOrder = IndexWithinEnabledSet = -1;
3087	PrevEnabledColumn = NextEnabledColumn = -1;
3088	SortOrder = -1;
3089	SortDirection = ImGuiSortDirection_None;
3090	DrawChannelCurrent = DrawChannelFrozen = DrawChannelUnfrozen = (ImU8)-1;
3091	}
3092	};
3093
3094	// Transient cell data stored per row.
3095	// sizeof() ~ 6 bytes
3096	struct ImGuiTableCellData
3097	{
3098	ImU32 BgColor; // Actual color
3099	ImGuiTableColumnIdx Column; // Column number
3100	};
3101
3102	// Parameters for TableAngledHeadersRowEx()
3103	// This may end up being refactored for more general purpose.
3104	// sizeof() ~ 12 bytes
3105	struct ImGuiTableHeaderData
3106	{
3107	ImGuiTableColumnIdx Index; // Column index
3108	ImU32 TextColor;
3109	ImU32 BgColor0;
3110	ImU32 BgColor1;
3111	};
3112
3113	// Per-instance data that needs preserving across frames (seemingly most others do not need to be preserved aside from debug needs. Does that means they could be moved to ImGuiTableTempData?)
3114	// sizeof() ~ 24 bytes
3115	struct ImGuiTableInstanceData
3116	{
3117	ImGuiID TableInstanceID;
3118	float LastOuterHeight; // Outer height from last frame
3119	float LastTopHeadersRowHeight; // Height of first consecutive header rows from last frame (FIXME: this is used assuming consecutive headers are in same frozen set)
3120	float LastFrozenHeight; // Height of frozen section from last frame
3121	int HoveredRowLast; // Index of row which was hovered last frame.
3122	int HoveredRowNext; // Index of row hovered this frame, set after encountering it.
3123
3124	ImGuiTableInstanceData() { TableInstanceID = 0; LastOuterHeight = LastTopHeadersRowHeight = LastFrozenHeight = 0.0f; HoveredRowLast = HoveredRowNext = -1; }
3125	};
3126
3127	// sizeof() ~ 592 bytes + heap allocs described in TableBeginInitMemory()
3128	struct IMGUI_API ImGuiTable
3129	{
3130	ImGuiID ID;
3131	ImGuiTableFlags Flags;
3132	void* RawData; // Single allocation to hold Columns[], DisplayOrderToIndex[], and RowCellData[]
3133	ImGuiTableTempData* TempData; // Transient data while table is active. Point within g.CurrentTableStack[]
3134	ImSpan<ImGuiTableColumn> Columns; // Point within RawData[]
3135	ImSpan<ImGuiTableColumnIdx> DisplayOrderToIndex; // Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1)
3136	ImSpan<ImGuiTableCellData> RowCellData; // Point within RawData[]. Store cells background requests for current row.
3137	ImBitArrayPtr EnabledMaskByDisplayOrder; // Column DisplayOrder -> IsEnabled map
3138	ImBitArrayPtr EnabledMaskByIndex; // Column Index -> IsEnabled map (== not hidden by user/api) in a format adequate for iterating column without touching cold data
3139	ImBitArrayPtr VisibleMaskByIndex; // Column Index -> IsVisibleX|IsVisibleY map (== not hidden by user/api && not hidden by scrolling/cliprect)
3140	ImGuiTableFlags SettingsLoadedFlags; // Which data were loaded from the .ini file (e.g. when order is not altered we won't save order)
3141	int SettingsOffset; // Offset in g.SettingsTables
3142	int LastFrameActive;
3143	int ColumnsCount; // Number of columns declared in BeginTable()
3144	int CurrentRow;
3145	int CurrentColumn;
3146	ImS16 InstanceCurrent; // Count of BeginTable() calls with same ID in the same frame (generally 0). This is a little bit similar to BeginCount for a window, but multiple tables with the same ID are multiple tables, they are just synced.
3147	ImS16 InstanceInteracted; // Mark which instance (generally 0) of the same ID is being interacted with
3148	float RowPosY1;
3149	float RowPosY2;
3150	float RowMinHeight; // Height submitted to TableNextRow()
3151	float RowCellPaddingY; // Top and bottom padding. Reloaded during row change.
3152	float RowTextBaseline;
3153	float RowIndentOffsetX;
3154	ImGuiTableRowFlags RowFlags : 16; // Current row flags, see ImGuiTableRowFlags_
3155	ImGuiTableRowFlags LastRowFlags : 16;
3156	int RowBgColorCounter; // Counter for alternating background colors (can be fast-forwarded by e.g clipper), not same as CurrentRow because header rows typically don't increase this.
3157	ImU32 RowBgColor[2]; // Background color override for current row.
3158	ImU32 BorderColorStrong;
3159	ImU32 BorderColorLight;
3160	float BorderX1;
3161	float BorderX2;
3162	float HostIndentX;
3163	float MinColumnWidth;
3164	float OuterPaddingX;
3165	float CellPaddingX; // Padding from each borders. Locked in BeginTable()/Layout.
3166	float CellSpacingX1; // Spacing between non-bordered cells. Locked in BeginTable()/Layout.
3167	float CellSpacingX2;
3168	float InnerWidth; // User value passed to BeginTable(), see comments at the top of BeginTable() for details.
3169	float ColumnsGivenWidth; // Sum of current column width
3170	float ColumnsAutoFitWidth; // Sum of ideal column width in order nothing to be clipped, used for auto-fitting and content width submission in outer window
3171	float ColumnsStretchSumWeights; // Sum of weight of all enabled stretching columns
3172	float ResizedColumnNextWidth;
3173	float ResizeLockMinContentsX2; // Lock minimum contents width while resizing down in order to not create feedback loops. But we allow growing the table.
3174	float RefScale; // Reference scale to be able to rescale columns on font/dpi changes.
3175	float AngledHeadersHeight; // Set by TableAngledHeadersRow(), used in TableUpdateLayout()
3176	float AngledHeadersSlope; // Set by TableAngledHeadersRow(), used in TableUpdateLayout()
3177	ImRect OuterRect; // Note: for non-scrolling table, OuterRect.Max.y is often FLT_MAX until EndTable(), unless a height has been specified in BeginTable().
3178	ImRect InnerRect; // InnerRect but without decoration. As with OuterRect, for non-scrolling tables, InnerRect.Max.y is "
3179	ImRect WorkRect;
3180	ImRect InnerClipRect;
3181	ImRect BgClipRect; // We use this to cpu-clip cell background color fill, evolve during the frame as we cross frozen rows boundaries
3182	ImRect Bg0ClipRectForDrawCmd; // Actual ImDrawCmd clip rect for BG0/1 channel. This tends to be == OuterWindow->ClipRect at BeginTable() because output in BG0/BG1 is cpu-clipped
3183	ImRect Bg2ClipRectForDrawCmd; // Actual ImDrawCmd clip rect for BG2 channel. This tends to be a correct, tight-fit, because output to BG2 are done by widgets relying on regular ClipRect.
3184	ImRect HostClipRect; // This is used to check if we can eventually merge our columns draw calls into the current draw call of the current window.
3185	ImRect HostBackupInnerClipRect; // Backup of InnerWindow->ClipRect during PushTableBackground()/PopTableBackground()
3186	ImGuiWindow* OuterWindow; // Parent window for the table
3187	ImGuiWindow* InnerWindow; // Window holding the table data (== OuterWindow or a child window)
3188	ImGuiTextBuffer ColumnsNames; // Contiguous buffer holding columns names
3189	ImDrawListSplitter* DrawSplitter; // Shortcut to TempData->DrawSplitter while in table. Isolate draw commands per columns to avoid switching clip rect constantly
3190	ImGuiTableInstanceData InstanceDataFirst;
3191	ImVector<ImGuiTableInstanceData> InstanceDataExtra; // FIXME-OPT: Using a small-vector pattern would be good.
3192	ImGuiTableColumnSortSpecs SortSpecsSingle;
3193	ImVector<ImGuiTableColumnSortSpecs> SortSpecsMulti; // FIXME-OPT: Using a small-vector pattern would be good.
3194	ImGuiTableSortSpecs SortSpecs; // Public facing sorts specs, this is what we return in TableGetSortSpecs()
3195	ImGuiTableColumnIdx SortSpecsCount;
3196	ImGuiTableColumnIdx ColumnsEnabledCount; // Number of enabled columns (<= ColumnsCount)
3197	ImGuiTableColumnIdx ColumnsEnabledFixedCount; // Number of enabled columns using fixed width (<= ColumnsCount)
3198	ImGuiTableColumnIdx DeclColumnsCount; // Count calls to TableSetupColumn()
3199	ImGuiTableColumnIdx AngledHeadersCount; // Count columns with angled headers
3200	ImGuiTableColumnIdx HoveredColumnBody; // Index of column whose visible region is being hovered. Important: == ColumnsCount when hovering empty region after the right-most column!
3201	ImGuiTableColumnIdx HoveredColumnBorder; // Index of column whose right-border is being hovered (for resizing).
3202	ImGuiTableColumnIdx HighlightColumnHeader; // Index of column which should be highlighted.
3203	ImGuiTableColumnIdx AutoFitSingleColumn; // Index of single column requesting auto-fit.
3204	ImGuiTableColumnIdx ResizedColumn; // Index of column being resized. Reset when InstanceCurrent==0.
3205	ImGuiTableColumnIdx LastResizedColumn; // Index of column being resized from previous frame.
3206	ImGuiTableColumnIdx HeldHeaderColumn; // Index of column header being held.
3207	ImGuiTableColumnIdx ReorderColumn; // Index of column being reordered. (not cleared)
3208	ImGuiTableColumnIdx ReorderColumnDir; // -1 or +1
3209	ImGuiTableColumnIdx LeftMostEnabledColumn; // Index of left-most non-hidden column.
3210	ImGuiTableColumnIdx RightMostEnabledColumn; // Index of right-most non-hidden column.
3211	ImGuiTableColumnIdx LeftMostStretchedColumn; // Index of left-most stretched column.
3212	ImGuiTableColumnIdx RightMostStretchedColumn; // Index of right-most stretched column.
3213	ImGuiTableColumnIdx ContextPopupColumn; // Column right-clicked on, of -1 if opening context menu from a neutral/empty spot
3214	ImGuiTableColumnIdx FreezeRowsRequest; // Requested frozen rows count
3215	ImGuiTableColumnIdx FreezeRowsCount; // Actual frozen row count (== FreezeRowsRequest, or == 0 when no scrolling offset)
3216	ImGuiTableColumnIdx FreezeColumnsRequest; // Requested frozen columns count
3217	ImGuiTableColumnIdx FreezeColumnsCount; // Actual frozen columns count (== FreezeColumnsRequest, or == 0 when no scrolling offset)
3218	ImGuiTableColumnIdx RowCellDataCurrent; // Index of current RowCellData[] entry in current row
3219	ImGuiTableDrawChannelIdx DummyDrawChannel; // Redirect non-visible columns here.
3220	ImGuiTableDrawChannelIdx Bg2DrawChannelCurrent; // For Selectable() and other widgets drawing across columns after the freezing line. Index within DrawSplitter.Channels[]
3221	ImGuiTableDrawChannelIdx Bg2DrawChannelUnfrozen;
3222	ImS8 NavLayer; // ImGuiNavLayer at the time of BeginTable().
3223	bool IsLayoutLocked; // Set by TableUpdateLayout() which is called when beginning the first row.
3224	bool IsInsideRow; // Set when inside TableBeginRow()/TableEndRow().
3225	bool IsInitializing;
3226	bool IsSortSpecsDirty;
3227	bool IsUsingHeaders; // Set when the first row had the ImGuiTableRowFlags_Headers flag.
3228	bool IsContextPopupOpen; // Set when default context menu is open (also see: ContextPopupColumn, InstanceInteracted).
3229	bool DisableDefaultContextMenu; // Disable default context menu. You may submit your own using TableBeginContextMenuPopup()/EndPopup()
3230	bool IsSettingsRequestLoad;
3231	bool IsSettingsDirty; // Set when table settings have changed and needs to be reported into ImGuiTableSetttings data.
3232	bool IsDefaultDisplayOrder; // Set when display order is unchanged from default (DisplayOrder contains 0...Count-1)
3233	bool IsResetAllRequest;
3234	bool IsResetDisplayOrderRequest;
3235	bool IsUnfrozenRows; // Set when we got past the frozen row.
3236	bool IsDefaultSizingPolicy; // Set if user didn't explicitly set a sizing policy in BeginTable()
3237	bool IsActiveIdAliveBeforeTable;
3238	bool IsActiveIdInTable;
3239	bool HasScrollbarYCurr; // Whether ANY instance of this table had a vertical scrollbar during the current frame.
3240	bool HasScrollbarYPrev; // Whether ANY instance of this table had a vertical scrollbar during the previous.
3241	bool MemoryCompacted;
3242	bool HostSkipItems; // Backup of InnerWindow->SkipItem at the end of BeginTable(), because we will overwrite InnerWindow->SkipItem on a per-column basis
3243
3244	ImGuiTable() { memset(s: this, c: 0, n: sizeof(*this)); LastFrameActive = -1; }
3245	~ImGuiTable() { IM_FREE(RawData); }
3246	};
3247
3248	// Transient data that are only needed between BeginTable() and EndTable(), those buffers are shared (1 per level of stacked table).
3249	// - Accessing those requires chasing an extra pointer so for very frequently used data we leave them in the main table structure.
3250	// - We also leave out of this structure data that tend to be particularly useful for debugging/metrics.
3251	// FIXME-TABLE: more transient data could be stored in a stacked ImGuiTableTempData: e.g. SortSpecs.
3252	// sizeof() ~ 136 bytes.
3253	struct IMGUI_API ImGuiTableTempData
3254	{
3255	int TableIndex; // Index in g.Tables.Buf[] pool
3256	float LastTimeActive; // Last timestamp this structure was used
3257	float AngledHeadersExtraWidth; // Used in EndTable()
3258	ImVector<ImGuiTableHeaderData> AngledHeadersRequests; // Used in TableAngledHeadersRow()
3259
3260	ImVec2 UserOuterSize; // outer_size.x passed to BeginTable()
3261	ImDrawListSplitter DrawSplitter;
3262
3263	ImRect HostBackupWorkRect; // Backup of InnerWindow->WorkRect at the end of BeginTable()
3264	ImRect HostBackupParentWorkRect; // Backup of InnerWindow->ParentWorkRect at the end of BeginTable()
3265	ImVec2 HostBackupPrevLineSize; // Backup of InnerWindow->DC.PrevLineSize at the end of BeginTable()
3266	ImVec2 HostBackupCurrLineSize; // Backup of InnerWindow->DC.CurrLineSize at the end of BeginTable()
3267	ImVec2 HostBackupCursorMaxPos; // Backup of InnerWindow->DC.CursorMaxPos at the end of BeginTable()
3268	ImVec1 HostBackupColumnsOffset; // Backup of OuterWindow->DC.ColumnsOffset at the end of BeginTable()
3269	float HostBackupItemWidth; // Backup of OuterWindow->DC.ItemWidth at the end of BeginTable()
3270	int HostBackupItemWidthStackSize;//Backup of OuterWindow->DC.ItemWidthStack.Size at the end of BeginTable()
3271
3272	ImGuiTableTempData() { memset(s: this, c: 0, n: sizeof(*this)); LastTimeActive = -1.0f; }
3273	};
3274
3275	// sizeof() ~ 16
3276	struct ImGuiTableColumnSettings
3277	{
3278	float WidthOrWeight;
3279	ImGuiID UserID;
3280	ImGuiTableColumnIdx Index;
3281	ImGuiTableColumnIdx DisplayOrder;
3282	ImGuiTableColumnIdx SortOrder;
3283	ImU8 SortDirection : 2;
3284	ImS8 IsEnabled : 2; // "Visible" in ini file
3285	ImU8 IsStretch : 1;
3286
3287	ImGuiTableColumnSettings()
3288	{
3289	WidthOrWeight = 0.0f;
3290	UserID = 0;
3291	Index = -1;
3292	DisplayOrder = SortOrder = -1;
3293	SortDirection = ImGuiSortDirection_None;
3294	IsEnabled = -1;
3295	IsStretch = 0;
3296	}
3297	};
3298
3299	// This is designed to be stored in a single ImChunkStream (1 header followed by N ImGuiTableColumnSettings, etc.)
3300	struct ImGuiTableSettings
3301	{
3302	ImGuiID ID; // Set to 0 to invalidate/delete the setting
3303	ImGuiTableFlags SaveFlags; // Indicate data we want to save using the Resizable/Reorderable/Sortable/Hideable flags (could be using its own flags..)
3304	float RefScale; // Reference scale to be able to rescale columns on font/dpi changes.
3305	ImGuiTableColumnIdx ColumnsCount;
3306	ImGuiTableColumnIdx ColumnsCountMax; // Maximum number of columns this settings instance can store, we can recycle a settings instance with lower number of columns but not higher
3307	bool WantApply; // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)
3308
3309	ImGuiTableSettings() { memset(s: this, c: 0, n: sizeof(*this)); }
3310	ImGuiTableColumnSettings* GetColumnSettings() { return (ImGuiTableColumnSettings*)(this + 1); }
3311	};
3312
3313	//-----------------------------------------------------------------------------
3314	// [SECTION] ImGui internal API
3315	// No guarantee of forward compatibility here!
3316	//-----------------------------------------------------------------------------
3317
3318	namespace ImGui
3319	{
3320	// Windows
3321	// We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
3322	// If this ever crashes because g.CurrentWindow is NULL, it means that either:
3323	// - ImGui::NewFrame() has never been called, which is illegal.
3324	// - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
3325	IMGUI_API ImGuiIO& GetIO(ImGuiContext* ctx);
3326	IMGUI_API ImGuiPlatformIO& GetPlatformIO(ImGuiContext* ctx);
3327	inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; }
3328	inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
3329	IMGUI_API ImGuiWindow* FindWindowByID(ImGuiID id);
3330	IMGUI_API ImGuiWindow* FindWindowByName(const char* name);
3331	IMGUI_API void UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window);
3332	IMGUI_API void UpdateWindowSkipRefresh(ImGuiWindow* window);
3333	IMGUI_API ImVec2 CalcWindowNextAutoFitSize(ImGuiWindow* window);
3334	IMGUI_API bool IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent, bool popup_hierarchy, bool dock_hierarchy);
3335	IMGUI_API bool IsWindowWithinBeginStackOf(ImGuiWindow* window, ImGuiWindow* potential_parent);
3336	IMGUI_API bool IsWindowAbove(ImGuiWindow* potential_above, ImGuiWindow* potential_below);
3337	IMGUI_API bool IsWindowNavFocusable(ImGuiWindow* window);
3338	IMGUI_API void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiCond cond = 0);
3339	IMGUI_API void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond = 0);
3340	IMGUI_API void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiCond cond = 0);
3341	IMGUI_API void SetWindowHitTestHole(ImGuiWindow* window, const ImVec2& pos, const ImVec2& size);
3342	IMGUI_API void SetWindowHiddenAndSkipItemsForCurrentFrame(ImGuiWindow* window);
3343	inline void SetWindowParentWindowForFocusRoute(ImGuiWindow* window, ImGuiWindow* parent_window) { window->ParentWindowForFocusRoute = parent_window; } // You may also use SetNextWindowClass()'s FocusRouteParentWindowId field.
3344	inline ImRect WindowRectAbsToRel(ImGuiWindow* window, const ImRect& r) { ImVec2 off = window->DC.CursorStartPos; return ImRect(r.Min.x - off.x, r.Min.y - off.y, r.Max.x - off.x, r.Max.y - off.y); }
3345	inline ImRect WindowRectRelToAbs(ImGuiWindow* window, const ImRect& r) { ImVec2 off = window->DC.CursorStartPos; return ImRect(r.Min.x + off.x, r.Min.y + off.y, r.Max.x + off.x, r.Max.y + off.y); }
3346	inline ImVec2 WindowPosAbsToRel(ImGuiWindow* window, const ImVec2& p) { ImVec2 off = window->DC.CursorStartPos; return ImVec2(p.x - off.x, p.y - off.y); }
3347	inline ImVec2 WindowPosRelToAbs(ImGuiWindow* window, const ImVec2& p) { ImVec2 off = window->DC.CursorStartPos; return ImVec2(p.x + off.x, p.y + off.y); }
3348
3349	// Windows: Display Order and Focus Order
3350	IMGUI_API void FocusWindow(ImGuiWindow* window, ImGuiFocusRequestFlags flags = 0);
3351	IMGUI_API void FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window, ImGuiViewport* filter_viewport, ImGuiFocusRequestFlags flags);
3352	IMGUI_API void BringWindowToFocusFront(ImGuiWindow* window);
3353	IMGUI_API void BringWindowToDisplayFront(ImGuiWindow* window);
3354	IMGUI_API void BringWindowToDisplayBack(ImGuiWindow* window);
3355	IMGUI_API void BringWindowToDisplayBehind(ImGuiWindow* window, ImGuiWindow* above_window);
3356	IMGUI_API int FindWindowDisplayIndex(ImGuiWindow* window);
3357	IMGUI_API ImGuiWindow* FindBottomMostVisibleWindowWithinBeginStack(ImGuiWindow* window);
3358
3359	// Windows: Idle, Refresh Policies [EXPERIMENTAL]
3360	IMGUI_API void SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags);
3361
3362	// Fonts, drawing
3363	IMGUI_API void RegisterUserTexture(ImTextureData* tex); // Register external texture. EXPERIMENTAL: DO NOT USE YET.
3364	IMGUI_API void UnregisterUserTexture(ImTextureData* tex);
3365	IMGUI_API void RegisterFontAtlas(ImFontAtlas* atlas);
3366	IMGUI_API void UnregisterFontAtlas(ImFontAtlas* atlas);
3367	IMGUI_API void SetCurrentFont(ImFont* font, float font_size_before_scaling, float font_size_after_scaling);
3368	IMGUI_API void UpdateCurrentFontSize(float restore_font_size_after_scaling);
3369	IMGUI_API void SetFontRasterizerDensity(float rasterizer_density);
3370	inline float GetFontRasterizerDensity() { return GImGui->FontRasterizerDensity; }
3371	inline float GetRoundedFontSize(float size) { return IM_ROUND(size); }
3372	IMGUI_API ImFont* GetDefaultFont();
3373	IMGUI_API void PushPasswordFont();
3374	IMGUI_API void PopPasswordFont();
3375	inline ImDrawList* GetForegroundDrawList(ImGuiWindow* window) { return GetForegroundDrawList(viewport: window->Viewport); }
3376	IMGUI_API void AddDrawListToDrawDataEx(ImDrawData* draw_data, ImVector<ImDrawList*>* out_list, ImDrawList* draw_list);
3377
3378	// Init
3379	IMGUI_API void Initialize();
3380	IMGUI_API void Shutdown(); // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
3381
3382	// NewFrame
3383	IMGUI_API void UpdateInputEvents(bool trickle_fast_inputs);
3384	IMGUI_API void UpdateHoveredWindowAndCaptureFlags(const ImVec2& mouse_pos);
3385	IMGUI_API void FindHoveredWindowEx(const ImVec2& pos, bool find_first_and_in_any_viewport, ImGuiWindow** out_hovered_window, ImGuiWindow** out_hovered_window_under_moving_window);
3386	IMGUI_API void StartMouseMovingWindow(ImGuiWindow* window);
3387	IMGUI_API void StartMouseMovingWindowOrNode(ImGuiWindow* window, ImGuiDockNode* node, bool undock);
3388	IMGUI_API void StopMouseMovingWindow();
3389	IMGUI_API void UpdateMouseMovingWindowNewFrame();
3390	IMGUI_API void UpdateMouseMovingWindowEndFrame();
3391
3392	// Generic context hooks
3393	IMGUI_API ImGuiID AddContextHook(ImGuiContext* context, const ImGuiContextHook* hook);
3394	IMGUI_API void RemoveContextHook(ImGuiContext* context, ImGuiID hook_to_remove);
3395	IMGUI_API void CallContextHooks(ImGuiContext* context, ImGuiContextHookType type);
3396
3397	// Viewports
3398	IMGUI_API void TranslateWindowsInViewport(ImGuiViewportP* viewport, const ImVec2& old_pos, const ImVec2& new_pos, const ImVec2& old_size, const ImVec2& new_size);
3399	IMGUI_API void ScaleWindowsInViewport(ImGuiViewportP* viewport, float scale);
3400	IMGUI_API void DestroyPlatformWindow(ImGuiViewportP* viewport);
3401	IMGUI_API void SetWindowViewport(ImGuiWindow* window, ImGuiViewportP* viewport);
3402	IMGUI_API void SetCurrentViewport(ImGuiWindow* window, ImGuiViewportP* viewport);
3403	IMGUI_API const ImGuiPlatformMonitor* GetViewportPlatformMonitor(ImGuiViewport* viewport);
3404	IMGUI_API ImGuiViewportP* FindHoveredViewportFromPlatformWindowStack(const ImVec2& mouse_platform_pos);
3405
3406	// Settings
3407	IMGUI_API void MarkIniSettingsDirty();
3408	IMGUI_API void MarkIniSettingsDirty(ImGuiWindow* window);
3409	IMGUI_API void ClearIniSettings();
3410	IMGUI_API void AddSettingsHandler(const ImGuiSettingsHandler* handler);
3411	IMGUI_API void RemoveSettingsHandler(const char* type_name);
3412	IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
3413
3414	// Settings - Windows
3415	IMGUI_API ImGuiWindowSettings* CreateNewWindowSettings(const char* name);
3416	IMGUI_API ImGuiWindowSettings* FindWindowSettingsByID(ImGuiID id);
3417	IMGUI_API ImGuiWindowSettings* FindWindowSettingsByWindow(ImGuiWindow* window);
3418	IMGUI_API void ClearWindowSettings(const char* name);
3419
3420	// Localization
3421	IMGUI_API void LocalizeRegisterEntries(const ImGuiLocEntry* entries, int count);
3422	inline const char* LocalizeGetMsg(ImGuiLocKey key) { ImGuiContext& g = *GImGui; const char* msg = g.LocalizationTable[key]; return msg ? msg : "*Missing Text*"; }
3423
3424	// Scrolling
3425	IMGUI_API void SetScrollX(ImGuiWindow* window, float scroll_x);
3426	IMGUI_API void SetScrollY(ImGuiWindow* window, float scroll_y);
3427	IMGUI_API void SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio);
3428	IMGUI_API void SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio);
3429
3430	// Early work-in-progress API (ScrollToItem() will become public)
3431	IMGUI_API void ScrollToItem(ImGuiScrollFlags flags = 0);
3432	IMGUI_API void ScrollToRect(ImGuiWindow* window, const ImRect& rect, ImGuiScrollFlags flags = 0);
3433	IMGUI_API ImVec2 ScrollToRectEx(ImGuiWindow* window, const ImRect& rect, ImGuiScrollFlags flags = 0);
3434	//#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
3435	inline void ScrollToBringRectIntoView(ImGuiWindow* window, const ImRect& rect) { ScrollToRect(window, rect, flags: ImGuiScrollFlags_KeepVisibleEdgeY); }
3436	//#endif
3437
3438	// Basic Accessors
3439	inline ImGuiItemStatusFlags GetItemStatusFlags() { ImGuiContext& g = *GImGui; return g.LastItemData.StatusFlags; }
3440	inline ImGuiItemFlags GetItemFlags() { ImGuiContext& g = *GImGui; return g.LastItemData.ItemFlags; }
3441	inline ImGuiID GetActiveID() { ImGuiContext& g = *GImGui; return g.ActiveId; }
3442	inline ImGuiID GetFocusID() { ImGuiContext& g = *GImGui; return g.NavId; }
3443	IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window);
3444	IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow* window);
3445	IMGUI_API void ClearActiveID();
3446	IMGUI_API ImGuiID GetHoveredID();
3447	IMGUI_API void SetHoveredID(ImGuiID id);
3448	IMGUI_API void KeepAliveID(ImGuiID id);
3449	IMGUI_API void MarkItemEdited(ImGuiID id); // Mark data associated to given item as "edited", used by IsItemDeactivatedAfterEdit() function.
3450	IMGUI_API void PushOverrideID(ImGuiID id); // Push given value as-is at the top of the ID stack (whereas PushID combines old and new hashes)
3451	IMGUI_API ImGuiID GetIDWithSeed(const char* str_id_begin, const char* str_id_end, ImGuiID seed);
3452	IMGUI_API ImGuiID GetIDWithSeed(int n, ImGuiID seed);
3453
3454	// Basic Helpers for widget code
3455	IMGUI_API void ItemSize(const ImVec2& size, float text_baseline_y = -1.0f);
3456	inline void ItemSize(const ImRect& bb, float text_baseline_y = -1.0f) { ItemSize(size: bb.GetSize(), text_baseline_y); } // FIXME: This is a misleading API since we expect CursorPos to be bb.Min.
3457	IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb = NULL, ImGuiItemFlags extra_flags = 0);
3458	IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id, ImGuiItemFlags item_flags);
3459	IMGUI_API bool IsWindowContentHoverable(ImGuiWindow* window, ImGuiHoveredFlags flags = 0);
3460	IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id);
3461	IMGUI_API void SetLastItemData(ImGuiID item_id, ImGuiItemFlags item_flags, ImGuiItemStatusFlags status_flags, const ImRect& item_rect);
3462	IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_w, float default_h);
3463	IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
3464	IMGUI_API void PushMultiItemsWidths(int components, float width_full);
3465	IMGUI_API void ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess, float width_min);
3466
3467	// Parameter stacks (shared)
3468	IMGUI_API const ImGuiStyleVarInfo* GetStyleVarInfo(ImGuiStyleVar idx);
3469	IMGUI_API void BeginDisabledOverrideReenable();
3470	IMGUI_API void EndDisabledOverrideReenable();
3471
3472	// Logging/Capture
3473	IMGUI_API void LogBegin(ImGuiLogFlags flags, int auto_open_depth); // -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name.
3474	IMGUI_API void LogToBuffer(int auto_open_depth = -1); // Start logging/capturing to internal buffer
3475	IMGUI_API void LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end = NULL);
3476	IMGUI_API void LogSetNextTextDecoration(const char* prefix, const char* suffix);
3477
3478	// Childs
3479	IMGUI_API bool BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags);
3480
3481	// Popups, Modals
3482	IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_window_flags);
3483	IMGUI_API bool BeginPopupMenuEx(ImGuiID id, const char* label, ImGuiWindowFlags extra_window_flags);
3484	IMGUI_API void OpenPopupEx(ImGuiID id, ImGuiPopupFlags popup_flags = ImGuiPopupFlags_None);
3485	IMGUI_API void ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup);
3486	IMGUI_API void ClosePopupsOverWindow(ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup);
3487	IMGUI_API void ClosePopupsExceptModals();
3488	IMGUI_API bool IsPopupOpen(ImGuiID id, ImGuiPopupFlags popup_flags);
3489	IMGUI_API ImRect GetPopupAllowedExtentRect(ImGuiWindow* window);
3490	IMGUI_API ImGuiWindow* GetTopMostPopupModal();
3491	IMGUI_API ImGuiWindow* GetTopMostAndVisiblePopupModal();
3492	IMGUI_API ImGuiWindow* FindBlockingModal(ImGuiWindow* window);
3493	IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow* window);
3494	IMGUI_API ImVec2 FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy);
3495
3496	// Tooltips
3497	IMGUI_API bool BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags extra_window_flags);
3498	IMGUI_API bool BeginTooltipHidden();
3499
3500	// Menus
3501	IMGUI_API bool BeginViewportSideBar(const char* name, ImGuiViewport* viewport, ImGuiDir dir, float size, ImGuiWindowFlags window_flags);
3502	IMGUI_API bool BeginMenuEx(const char* label, const char* icon, bool enabled = true);
3503	IMGUI_API bool MenuItemEx(const char* label, const char* icon, const char* shortcut = NULL, bool selected = false, bool enabled = true);
3504
3505	// Combos
3506	IMGUI_API bool BeginComboPopup(ImGuiID popup_id, const ImRect& bb, ImGuiComboFlags flags);
3507	IMGUI_API bool BeginComboPreview();
3508	IMGUI_API void EndComboPreview();
3509
3510	// Keyboard/Gamepad Navigation
3511	IMGUI_API void NavInitWindow(ImGuiWindow* window, bool force_reinit);
3512	IMGUI_API void NavInitRequestApplyResult();
3513	IMGUI_API bool NavMoveRequestButNoResultYet();
3514	IMGUI_API void NavMoveRequestSubmit(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags);
3515	IMGUI_API void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags);
3516	IMGUI_API void NavMoveRequestResolveWithLastItem(ImGuiNavItemData* result);
3517	IMGUI_API void NavMoveRequestResolveWithPastTreeNode(ImGuiNavItemData* result, const ImGuiTreeNodeStackData* tree_node_data);
3518	IMGUI_API void NavMoveRequestCancel();
3519	IMGUI_API void NavMoveRequestApplyResult();
3520	IMGUI_API void NavMoveRequestTryWrapping(ImGuiWindow* window, ImGuiNavMoveFlags move_flags);
3521	IMGUI_API void NavHighlightActivated(ImGuiID id);
3522	IMGUI_API void NavClearPreferredPosForAxis(ImGuiAxis axis);
3523	IMGUI_API void SetNavCursorVisibleAfterMove();
3524	IMGUI_API void NavUpdateCurrentWindowIsScrollPushableX();
3525	IMGUI_API void SetNavWindow(ImGuiWindow* window);
3526	IMGUI_API void SetNavID(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel);
3527	IMGUI_API void SetNavFocusScope(ImGuiID focus_scope_id);
3528
3529	// Focus/Activation
3530	// This should be part of a larger set of API: FocusItem(offset = -1), FocusItemByID(id), ActivateItem(offset = -1), ActivateItemByID(id) etc. which are
3531	// much harder to design and implement than expected. I have a couple of private branches on this matter but it's not simple. For now implementing the easy ones.
3532	IMGUI_API void FocusItem(); // Focus last item (no selection/activation).
3533	IMGUI_API void ActivateItemByID(ImGuiID id); // Activate an item by ID (button, checkbox, tree node etc.). Activation is queued and processed on the next frame when the item is encountered again. Was called 'ActivateItem()' before 1.89.7.
3534
3535	// Inputs
3536	// FIXME: Eventually we should aim to move e.g. IsActiveIdUsingKey() into IsKeyXXX functions.
3537	inline bool IsNamedKey(ImGuiKey key) { return key >= ImGuiKey_NamedKey_BEGIN && key < ImGuiKey_NamedKey_END; }
3538	inline bool IsNamedKeyOrMod(ImGuiKey key) { return (key >= ImGuiKey_NamedKey_BEGIN && key < ImGuiKey_NamedKey_END) || key == ImGuiMod_Ctrl || key == ImGuiMod_Shift || key == ImGuiMod_Alt || key == ImGuiMod_Super; }
3539	inline bool IsLegacyKey(ImGuiKey key) { return key >= ImGuiKey_LegacyNativeKey_BEGIN && key < ImGuiKey_LegacyNativeKey_END; }
3540	inline bool IsKeyboardKey(ImGuiKey key) { return key >= ImGuiKey_Keyboard_BEGIN && key < ImGuiKey_Keyboard_END; }
3541	inline bool IsGamepadKey(ImGuiKey key) { return key >= ImGuiKey_Gamepad_BEGIN && key < ImGuiKey_Gamepad_END; }
3542	inline bool IsMouseKey(ImGuiKey key) { return key >= ImGuiKey_Mouse_BEGIN && key < ImGuiKey_Mouse_END; }
3543	inline bool IsAliasKey(ImGuiKey key) { return key >= ImGuiKey_Aliases_BEGIN && key < ImGuiKey_Aliases_END; }
3544	inline bool IsLRModKey(ImGuiKey key) { return key >= ImGuiKey_LeftCtrl && key <= ImGuiKey_RightSuper; }
3545	ImGuiKeyChord FixupKeyChord(ImGuiKeyChord key_chord);
3546	inline ImGuiKey ConvertSingleModFlagToKey(ImGuiKey key)
3547	{
3548	if (key == ImGuiMod_Ctrl) return ImGuiKey_ReservedForModCtrl;
3549	if (key == ImGuiMod_Shift) return ImGuiKey_ReservedForModShift;
3550	if (key == ImGuiMod_Alt) return ImGuiKey_ReservedForModAlt;
3551	if (key == ImGuiMod_Super) return ImGuiKey_ReservedForModSuper;
3552	return key;
3553	}
3554
3555	IMGUI_API ImGuiKeyData* GetKeyData(ImGuiContext* ctx, ImGuiKey key);
3556	inline ImGuiKeyData* GetKeyData(ImGuiKey key) { ImGuiContext& g = *GImGui; return GetKeyData(ctx: &g, key); }
3557	IMGUI_API const char* GetKeyChordName(ImGuiKeyChord key_chord);
3558	inline ImGuiKey MouseButtonToKey(ImGuiMouseButton button) { IM_ASSERT(button >= 0 && button < ImGuiMouseButton_COUNT); return (ImGuiKey)(ImGuiKey_MouseLeft + button); }
3559	IMGUI_API bool IsMouseDragPastThreshold(ImGuiMouseButton button, float lock_threshold = -1.0f);
3560	IMGUI_API ImVec2 GetKeyMagnitude2d(ImGuiKey key_left, ImGuiKey key_right, ImGuiKey key_up, ImGuiKey key_down);
3561	IMGUI_API float GetNavTweakPressedAmount(ImGuiAxis axis);
3562	IMGUI_API int CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate);
3563	IMGUI_API void GetTypematicRepeatRate(ImGuiInputFlags flags, float* repeat_delay, float* repeat_rate);
3564	IMGUI_API void TeleportMousePos(const ImVec2& pos);
3565	IMGUI_API void SetActiveIdUsingAllKeyboardKeys();
3566	inline bool IsActiveIdUsingNavDir(ImGuiDir dir) { ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavDirMask & (1 << dir)) != 0; }
3567
3568	// [EXPERIMENTAL] Low-Level: Key/Input Ownership
3569	// - The idea is that instead of "eating" a given input, we can link to an owner id.
3570	// - Ownership is most often claimed as a result of reacting to a press/down event (but occasionally may be claimed ahead).
3571	// - Input queries can then read input by specifying ImGuiKeyOwner_Any (== 0), ImGuiKeyOwner_NoOwner (== -1) or a custom ID.
3572	// - Legacy input queries (without specifying an owner or _Any or _None) are equivalent to using ImGuiKeyOwner_Any (== 0).
3573	// - Input ownership is automatically released on the frame after a key is released. Therefore:
3574	// - for ownership registration happening as a result of a down/press event, the SetKeyOwner() call may be done once (common case).
3575	// - for ownership registration happening ahead of a down/press event, the SetKeyOwner() call needs to be made every frame (happens if e.g. claiming ownership on hover).
3576	// - SetItemKeyOwner() is a shortcut for common simple case. A custom widget will probably want to call SetKeyOwner() multiple times directly based on its interaction state.
3577	// - This is marked experimental because not all widgets are fully honoring the Set/Test idioms. We will need to move forward step by step.
3578	// Please open a GitHub Issue to submit your usage scenario or if there's a use case you need solved.
3579	IMGUI_API ImGuiID GetKeyOwner(ImGuiKey key);
3580	IMGUI_API void SetKeyOwner(ImGuiKey key, ImGuiID owner_id, ImGuiInputFlags flags = 0);
3581	IMGUI_API void SetKeyOwnersForKeyChord(ImGuiKeyChord key, ImGuiID owner_id, ImGuiInputFlags flags = 0);
3582	IMGUI_API void SetItemKeyOwner(ImGuiKey key, ImGuiInputFlags flags); // Set key owner to last item if it is hovered or active. Equivalent to 'if (IsItemHovered() || IsItemActive()) { SetKeyOwner(key, GetItemID());'.
3583	IMGUI_API bool TestKeyOwner(ImGuiKey key, ImGuiID owner_id); // Test that key is either not owned, either owned by 'owner_id'
3584	inline ImGuiKeyOwnerData* GetKeyOwnerData(ImGuiContext* ctx, ImGuiKey key) { if (key & ImGuiMod_Mask_) key = ConvertSingleModFlagToKey(key); IM_ASSERT(IsNamedKey(key)); return &ctx->KeysOwnerData[key - ImGuiKey_NamedKey_BEGIN]; }
3585
3586	// [EXPERIMENTAL] High-Level: Input Access functions w/ support for Key/Input Ownership
3587	// - Important: legacy IsKeyPressed(ImGuiKey, bool repeat=true) _DEFAULTS_ to repeat, new IsKeyPressed() requires _EXPLICIT_ ImGuiInputFlags_Repeat flag.
3588	// - Expected to be later promoted to public API, the prototypes are designed to replace existing ones (since owner_id can default to Any == 0)
3589	// - Specifying a value for 'ImGuiID owner' will test that EITHER the key is NOT owned (UNLESS locked), EITHER the key is owned by 'owner'.
3590	// Legacy functions use ImGuiKeyOwner_Any meaning that they typically ignore ownership, unless a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease.
3591	// - Binding generators may want to ignore those for now, or suffix them with Ex() until we decide if this gets moved into public API.
3592	IMGUI_API bool IsKeyDown(ImGuiKey key, ImGuiID owner_id);
3593	IMGUI_API bool IsKeyPressed(ImGuiKey key, ImGuiInputFlags flags, ImGuiID owner_id = 0); // Important: when transitioning from old to new IsKeyPressed(): old API has "bool repeat = true", so would default to repeat. New API requiress explicit ImGuiInputFlags_Repeat.
3594	IMGUI_API bool IsKeyReleased(ImGuiKey key, ImGuiID owner_id);
3595	IMGUI_API bool IsKeyChordPressed(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id = 0);
3596	IMGUI_API bool IsMouseDown(ImGuiMouseButton button, ImGuiID owner_id);
3597	IMGUI_API bool IsMouseClicked(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id = 0);
3598	IMGUI_API bool IsMouseReleased(ImGuiMouseButton button, ImGuiID owner_id);
3599	IMGUI_API bool IsMouseDoubleClicked(ImGuiMouseButton button, ImGuiID owner_id);
3600
3601	// Shortcut Testing & Routing
3602	// - Set Shortcut() and SetNextItemShortcut() in imgui.h
3603	// - When a policy (except for ImGuiInputFlags_RouteAlways *) is set, Shortcut() will register itself with SetShortcutRouting(),
3604	// allowing the system to decide where to route the input among other route-aware calls.
3605	// (* using ImGuiInputFlags_RouteAlways is roughly equivalent to calling IsKeyChordPressed(key) and bypassing route registration and check)
3606	// - When using one of the routing option:
3607	// - The default route is ImGuiInputFlags_RouteFocused (accept inputs if window is in focus stack. Deep-most focused window takes inputs. ActiveId takes inputs over deep-most focused window.)
3608	// - Routes are requested given a chord (key + modifiers) and a routing policy.
3609	// - Routes are resolved during NewFrame(): if keyboard modifiers are matching current ones: SetKeyOwner() is called + route is granted for the frame.
3610	// - Each route may be granted to a single owner. When multiple requests are made we have policies to select the winning route (e.g. deep most window).
3611	// - Multiple read sites may use the same owner id can all access the granted route.
3612	// - When owner_id is 0 we use the current Focus Scope ID as a owner ID in order to identify our location.
3613	// - You can chain two unrelated windows in the focus stack using SetWindowParentWindowForFocusRoute()
3614	// e.g. if you have a tool window associated to a document, and you want document shortcuts to run when the tool is focused.
3615	IMGUI_API bool Shortcut(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id);
3616	IMGUI_API bool SetShortcutRouting(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id); // owner_id needs to be explicit and cannot be 0
3617	IMGUI_API bool TestShortcutRouting(ImGuiKeyChord key_chord, ImGuiID owner_id);
3618	IMGUI_API ImGuiKeyRoutingData* GetShortcutRoutingData(ImGuiKeyChord key_chord);
3619
3620	// Docking
3621	// (some functions are only declared in imgui.cpp, see Docking section)
3622	IMGUI_API void DockContextInitialize(ImGuiContext* ctx);
3623	IMGUI_API void DockContextShutdown(ImGuiContext* ctx);
3624	IMGUI_API void DockContextClearNodes(ImGuiContext* ctx, ImGuiID root_id, bool clear_settings_refs); // Use root_id==0 to clear all
3625	IMGUI_API void DockContextRebuildNodes(ImGuiContext* ctx);
3626	IMGUI_API void DockContextNewFrameUpdateUndocking(ImGuiContext* ctx);
3627	IMGUI_API void DockContextNewFrameUpdateDocking(ImGuiContext* ctx);
3628	IMGUI_API void DockContextEndFrame(ImGuiContext* ctx);
3629	IMGUI_API ImGuiID DockContextGenNodeID(ImGuiContext* ctx);
3630	IMGUI_API void DockContextQueueDock(ImGuiContext* ctx, ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload, ImGuiDir split_dir, float split_ratio, bool split_outer);
3631	IMGUI_API void DockContextQueueUndockWindow(ImGuiContext* ctx, ImGuiWindow* window);
3632	IMGUI_API void DockContextQueueUndockNode(ImGuiContext* ctx, ImGuiDockNode* node);
3633	IMGUI_API void DockContextProcessUndockWindow(ImGuiContext* ctx, ImGuiWindow* window, bool clear_persistent_docking_ref = true);
3634	IMGUI_API void DockContextProcessUndockNode(ImGuiContext* ctx, ImGuiDockNode* node);
3635	IMGUI_API bool DockContextCalcDropPosForDocking(ImGuiWindow* target, ImGuiDockNode* target_node, ImGuiWindow* payload_window, ImGuiDockNode* payload_node, ImGuiDir split_dir, bool split_outer, ImVec2* out_pos);
3636	IMGUI_API ImGuiDockNode*DockContextFindNodeByID(ImGuiContext* ctx, ImGuiID id);
3637	IMGUI_API void DockNodeWindowMenuHandler_Default(ImGuiContext* ctx, ImGuiDockNode* node, ImGuiTabBar* tab_bar);
3638	IMGUI_API bool DockNodeBeginAmendTabBar(ImGuiDockNode* node);
3639	IMGUI_API void DockNodeEndAmendTabBar();
3640	inline ImGuiDockNode* DockNodeGetRootNode(ImGuiDockNode* node) { while (node->ParentNode) node = node->ParentNode; return node; }
3641	inline bool DockNodeIsInHierarchyOf(ImGuiDockNode* node, ImGuiDockNode* parent) { while (node) { if (node == parent) return true; node = node->ParentNode; } return false; }
3642	inline int DockNodeGetDepth(const ImGuiDockNode* node) { int depth = 0; while (node->ParentNode) { node = node->ParentNode; depth++; } return depth; }
3643	inline ImGuiID DockNodeGetWindowMenuButtonId(const ImGuiDockNode* node) { return ImHashStr(data: "#COLLAPSE", data_size: 0, seed: node->ID); }
3644	inline ImGuiDockNode* GetWindowDockNode() { ImGuiContext& g = *GImGui; return g.CurrentWindow->DockNode; }
3645	IMGUI_API bool GetWindowAlwaysWantOwnTabBar(ImGuiWindow* window);
3646	IMGUI_API void BeginDocked(ImGuiWindow* window, bool* p_open);
3647	IMGUI_API void BeginDockableDragDropSource(ImGuiWindow* window);
3648	IMGUI_API void BeginDockableDragDropTarget(ImGuiWindow* window);
3649	IMGUI_API void SetWindowDock(ImGuiWindow* window, ImGuiID dock_id, ImGuiCond cond);
3650
3651	// Docking - Builder function needs to be generally called before the node is used/submitted.
3652	// - The DockBuilderXXX functions are designed to _eventually_ become a public API, but it is too early to expose it and guarantee stability.
3653	// - Do not hold on ImGuiDockNode* pointers! They may be invalidated by any split/merge/remove operation and every frame.
3654	// - To create a DockSpace() node, make sure to set the ImGuiDockNodeFlags_DockSpace flag when calling DockBuilderAddNode().
3655	// You can create dockspace nodes (attached to a window) _or_ floating nodes (carry its own window) with this API.
3656	// - DockBuilderSplitNode() create 2 child nodes within 1 node. The initial node becomes a parent node.
3657	// - If you intend to split the node immediately after creation using DockBuilderSplitNode(), make sure
3658	// to call DockBuilderSetNodeSize() beforehand. If you don't, the resulting split sizes may not be reliable.
3659	// - Call DockBuilderFinish() after you are done.
3660	IMGUI_API void DockBuilderDockWindow(const char* window_name, ImGuiID node_id);
3661	IMGUI_API ImGuiDockNode*DockBuilderGetNode(ImGuiID node_id);
3662	inline ImGuiDockNode* DockBuilderGetCentralNode(ImGuiID node_id) { ImGuiDockNode* node = DockBuilderGetNode(node_id); if (!node) return NULL; return DockNodeGetRootNode(node)->CentralNode; }
3663	IMGUI_API ImGuiID DockBuilderAddNode(ImGuiID node_id = 0, ImGuiDockNodeFlags flags = 0);
3664	IMGUI_API void DockBuilderRemoveNode(ImGuiID node_id); // Remove node and all its child, undock all windows
3665	IMGUI_API void DockBuilderRemoveNodeDockedWindows(ImGuiID node_id, bool clear_settings_refs = true);
3666	IMGUI_API void DockBuilderRemoveNodeChildNodes(ImGuiID node_id); // Remove all split/hierarchy. All remaining docked windows will be re-docked to the remaining root node (node_id).
3667	IMGUI_API void DockBuilderSetNodePos(ImGuiID node_id, ImVec2 pos);
3668	IMGUI_API void DockBuilderSetNodeSize(ImGuiID node_id, ImVec2 size);
3669	IMGUI_API ImGuiID DockBuilderSplitNode(ImGuiID node_id, ImGuiDir split_dir, float size_ratio_for_node_at_dir, ImGuiID* out_id_at_dir, ImGuiID* out_id_at_opposite_dir); // Create 2 child nodes in this parent node.
3670	IMGUI_API void DockBuilderCopyDockSpace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id, ImVector<const char*>* in_window_remap_pairs);
3671	IMGUI_API void DockBuilderCopyNode(ImGuiID src_node_id, ImGuiID dst_node_id, ImVector<ImGuiID>* out_node_remap_pairs);
3672	IMGUI_API void DockBuilderCopyWindowSettings(const char* src_name, const char* dst_name);
3673	IMGUI_API void DockBuilderFinish(ImGuiID node_id);
3674
3675	// [EXPERIMENTAL] Focus Scope
3676	// This is generally used to identify a unique input location (for e.g. a selection set)
3677	// There is one per window (automatically set in Begin), but:
3678	// - Selection patterns generally need to react (e.g. clear a selection) when landing on one item of the set.
3679	// So in order to identify a set multiple lists in same window may each need a focus scope.
3680	// If you imagine an hypothetical BeginSelectionGroup()/EndSelectionGroup() api, it would likely call PushFocusScope()/EndFocusScope()
3681	// - Shortcut routing also use focus scope as a default location identifier if an owner is not provided.
3682	// We don't use the ID Stack for this as it is common to want them separate.
3683	IMGUI_API void PushFocusScope(ImGuiID id);
3684	IMGUI_API void PopFocusScope();
3685	inline ImGuiID GetCurrentFocusScope() { ImGuiContext& g = *GImGui; return g.CurrentFocusScopeId; } // Focus scope we are outputting into, set by PushFocusScope()
3686
3687	// Drag and Drop
3688	IMGUI_API bool IsDragDropActive();
3689	IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
3690	IMGUI_API void ClearDragDrop();
3691	IMGUI_API bool IsDragDropPayloadBeingAccepted();
3692	IMGUI_API void RenderDragDropTargetRect(const ImRect& bb, const ImRect& item_clip_rect);
3693
3694	// Typing-Select API
3695	// (provide Windows Explorer style "select items by typing partial name" + "cycle through items by typing same letter" feature)
3696	// (this is currently not documented nor used by main library, but should work. See "widgets_typingselect" in imgui_test_suite for usage code. Please let us know if you use this!)
3697	IMGUI_API ImGuiTypingSelectRequest* GetTypingSelectRequest(ImGuiTypingSelectFlags flags = ImGuiTypingSelectFlags_None);
3698	IMGUI_API int TypingSelectFindMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx);
3699	IMGUI_API int TypingSelectFindNextSingleCharMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data, int nav_item_idx);
3700	IMGUI_API int TypingSelectFindBestLeadingMatch(ImGuiTypingSelectRequest* req, int items_count, const char* (*get_item_name_func)(void*, int), void* user_data);
3701
3702	// Box-Select API
3703	IMGUI_API bool BeginBoxSelect(const ImRect& scope_rect, ImGuiWindow* window, ImGuiID box_select_id, ImGuiMultiSelectFlags ms_flags);
3704	IMGUI_API void EndBoxSelect(const ImRect& scope_rect, ImGuiMultiSelectFlags ms_flags);
3705
3706	// Multi-Select API
3707	IMGUI_API void MultiSelectItemHeader(ImGuiID id, bool* p_selected, ImGuiButtonFlags* p_button_flags);
3708	IMGUI_API void MultiSelectItemFooter(ImGuiID id, bool* p_selected, bool* p_pressed);
3709	IMGUI_API void MultiSelectAddSetAll(ImGuiMultiSelectTempData* ms, bool selected);
3710	IMGUI_API void MultiSelectAddSetRange(ImGuiMultiSelectTempData* ms, bool selected, int range_dir, ImGuiSelectionUserData first_item, ImGuiSelectionUserData last_item);
3711	inline ImGuiBoxSelectState* GetBoxSelectState(ImGuiID id) { ImGuiContext& g = *GImGui; return (id != 0 && g.BoxSelectState.ID == id && g.BoxSelectState.IsActive) ? &g.BoxSelectState : NULL; }
3712	inline ImGuiMultiSelectState* GetMultiSelectState(ImGuiID id) { ImGuiContext& g = *GImGui; return g.MultiSelectStorage.GetByKey(key: id); }
3713
3714	// Internal Columns API (this is not exposed because we will encourage transitioning to the Tables API)
3715	IMGUI_API void SetWindowClipRectBeforeSetChannel(ImGuiWindow* window, const ImRect& clip_rect);
3716	IMGUI_API void BeginColumns(const char* str_id, int count, ImGuiOldColumnFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
3717	IMGUI_API void EndColumns(); // close columns
3718	IMGUI_API void PushColumnClipRect(int column_index);
3719	IMGUI_API void PushColumnsBackground();
3720	IMGUI_API void PopColumnsBackground();
3721	IMGUI_API ImGuiID GetColumnsID(const char* str_id, int count);
3722	IMGUI_API ImGuiOldColumns* FindOrCreateColumns(ImGuiWindow* window, ImGuiID id);
3723	IMGUI_API float GetColumnOffsetFromNorm(const ImGuiOldColumns* columns, float offset_norm);
3724	IMGUI_API float GetColumnNormFromOffset(const ImGuiOldColumns* columns, float offset);
3725
3726	// Tables: Candidates for public API
3727	IMGUI_API void TableOpenContextMenu(int column_n = -1);
3728	IMGUI_API void TableSetColumnWidth(int column_n, float width);
3729	IMGUI_API void TableSetColumnSortDirection(int column_n, ImGuiSortDirection sort_direction, bool append_to_sort_specs);
3730	IMGUI_API int TableGetHoveredRow(); // Retrieve *PREVIOUS FRAME* hovered row. This difference with TableGetHoveredColumn() is the reason why this is not public yet.
3731	IMGUI_API float TableGetHeaderRowHeight();
3732	IMGUI_API float TableGetHeaderAngledMaxLabelWidth();
3733	IMGUI_API void TablePushBackgroundChannel();
3734	IMGUI_API void TablePopBackgroundChannel();
3735	IMGUI_API void TablePushColumnChannel(int column_n);
3736	IMGUI_API void TablePopColumnChannel();
3737	IMGUI_API void TableAngledHeadersRowEx(ImGuiID row_id, float angle, float max_label_width, const ImGuiTableHeaderData* data, int data_count);
3738
3739	// Tables: Internals
3740	inline ImGuiTable* GetCurrentTable() { ImGuiContext& g = *GImGui; return g.CurrentTable; }
3741	IMGUI_API ImGuiTable* TableFindByID(ImGuiID id);
3742	IMGUI_API bool BeginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags = 0, const ImVec2& outer_size = ImVec2(0, 0), float inner_width = 0.0f);
3743	IMGUI_API void TableBeginInitMemory(ImGuiTable* table, int columns_count);
3744	IMGUI_API void TableBeginApplyRequests(ImGuiTable* table);
3745	IMGUI_API void TableSetupDrawChannels(ImGuiTable* table);
3746	IMGUI_API void TableUpdateLayout(ImGuiTable* table);
3747	IMGUI_API void TableUpdateBorders(ImGuiTable* table);
3748	IMGUI_API void TableUpdateColumnsWeightFromWidth(ImGuiTable* table);
3749	IMGUI_API void TableDrawBorders(ImGuiTable* table);
3750	IMGUI_API void TableDrawDefaultContextMenu(ImGuiTable* table, ImGuiTableFlags flags_for_section_to_display);
3751	IMGUI_API bool TableBeginContextMenuPopup(ImGuiTable* table);
3752	IMGUI_API void TableMergeDrawChannels(ImGuiTable* table);
3753	inline ImGuiTableInstanceData* TableGetInstanceData(ImGuiTable* table, int instance_no) { if (instance_no == 0) return &table->InstanceDataFirst; return &table->InstanceDataExtra[instance_no - 1]; }
3754	inline ImGuiID TableGetInstanceID(ImGuiTable* table, int instance_no) { return TableGetInstanceData(table, instance_no)->TableInstanceID; }
3755	IMGUI_API void TableSortSpecsSanitize(ImGuiTable* table);
3756	IMGUI_API void TableSortSpecsBuild(ImGuiTable* table);
3757	IMGUI_API ImGuiSortDirection TableGetColumnNextSortDirection(ImGuiTableColumn* column);
3758	IMGUI_API void TableFixColumnSortDirection(ImGuiTable* table, ImGuiTableColumn* column);
3759	IMGUI_API float TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column);
3760	IMGUI_API void TableBeginRow(ImGuiTable* table);
3761	IMGUI_API void TableEndRow(ImGuiTable* table);
3762	IMGUI_API void TableBeginCell(ImGuiTable* table, int column_n);
3763	IMGUI_API void TableEndCell(ImGuiTable* table);
3764	IMGUI_API ImRect TableGetCellBgRect(const ImGuiTable* table, int column_n);
3765	IMGUI_API const char* TableGetColumnName(const ImGuiTable* table, int column_n);
3766	IMGUI_API ImGuiID TableGetColumnResizeID(ImGuiTable* table, int column_n, int instance_no = 0);
3767	IMGUI_API float TableCalcMaxColumnWidth(const ImGuiTable* table, int column_n);
3768	IMGUI_API void TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n);
3769	IMGUI_API void TableSetColumnWidthAutoAll(ImGuiTable* table);
3770	IMGUI_API void TableRemove(ImGuiTable* table);
3771	IMGUI_API void TableGcCompactTransientBuffers(ImGuiTable* table);
3772	IMGUI_API void TableGcCompactTransientBuffers(ImGuiTableTempData* table);
3773	IMGUI_API void TableGcCompactSettings();
3774
3775	// Tables: Settings
3776	IMGUI_API void TableLoadSettings(ImGuiTable* table);
3777	IMGUI_API void TableSaveSettings(ImGuiTable* table);
3778	IMGUI_API void TableResetSettings(ImGuiTable* table);
3779	IMGUI_API ImGuiTableSettings* TableGetBoundSettings(ImGuiTable* table);
3780	IMGUI_API void TableSettingsAddSettingsHandler();
3781	IMGUI_API ImGuiTableSettings* TableSettingsCreate(ImGuiID id, int columns_count);
3782	IMGUI_API ImGuiTableSettings* TableSettingsFindByID(ImGuiID id);
3783
3784	// Tab Bars
3785	inline ImGuiTabBar* GetCurrentTabBar() { ImGuiContext& g = *GImGui; return g.CurrentTabBar; }
3786	IMGUI_API bool BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& bb, ImGuiTabBarFlags flags);
3787	IMGUI_API ImGuiTabItem* TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id);
3788	IMGUI_API ImGuiTabItem* TabBarFindTabByOrder(ImGuiTabBar* tab_bar, int order);
3789	IMGUI_API ImGuiTabItem* TabBarFindMostRecentlySelectedTabForActiveWindow(ImGuiTabBar* tab_bar);
3790	IMGUI_API ImGuiTabItem* TabBarGetCurrentTab(ImGuiTabBar* tab_bar);
3791	inline int TabBarGetTabOrder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) { return tab_bar->Tabs.index_from_ptr(it: tab); }
3792	IMGUI_API const char* TabBarGetTabName(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
3793	IMGUI_API void TabBarAddTab(ImGuiTabBar* tab_bar, ImGuiTabItemFlags tab_flags, ImGuiWindow* window);
3794	IMGUI_API void TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id);
3795	IMGUI_API void TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
3796	IMGUI_API void TabBarQueueFocus(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
3797	IMGUI_API void TabBarQueueFocus(ImGuiTabBar* tab_bar, const char* tab_name);
3798	IMGUI_API void TabBarQueueReorder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, int offset);
3799	IMGUI_API void TabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar, ImGuiTabItem* tab, ImVec2 mouse_pos);
3800	IMGUI_API bool TabBarProcessReorder(ImGuiTabBar* tab_bar);
3801	IMGUI_API bool TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags, ImGuiWindow* docked_window);
3802	IMGUI_API void TabItemSpacing(const char* str_id, ImGuiTabItemFlags flags, float width);
3803	IMGUI_API ImVec2 TabItemCalcSize(const char* label, bool has_close_button_or_unsaved_marker);
3804	IMGUI_API ImVec2 TabItemCalcSize(ImGuiWindow* window);
3805	IMGUI_API void TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col);
3806	IMGUI_API void TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible, bool* out_just_closed, bool* out_text_clipped);
3807
3808	// Render helpers
3809	// AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
3810	// NB: All position are in absolute pixels coordinates (we are never using window coordinates internally)
3811	IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
3812	IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
3813	IMGUI_API void RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
3814	IMGUI_API void RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
3815	IMGUI_API void RenderTextEllipsis(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, float ellipsis_max_x, const char* text, const char* text_end, const ImVec2* text_size_if_known);
3816	IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool borders = true, float rounding = 0.0f);
3817	IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
3818	IMGUI_API void RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, ImDrawFlags flags = 0);
3819	IMGUI_API void RenderNavCursor(const ImRect& bb, ImGuiID id, ImGuiNavRenderCursorFlags flags = ImGuiNavRenderCursorFlags_None); // Navigation highlight
3820	#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
3821	inline void RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavRenderCursorFlags flags = ImGuiNavRenderCursorFlags_None) { RenderNavCursor(bb, id, flags); } // Renamed in 1.91.4
3822	#endif
3823	IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
3824	IMGUI_API void RenderMouseCursor(ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow);
3825
3826	// Render helpers (those functions don't access any ImGui state!)
3827	IMGUI_API void RenderArrow(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir, float scale = 1.0f);
3828	IMGUI_API void RenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col);
3829	IMGUI_API void RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz);
3830	IMGUI_API void RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col);
3831	IMGUI_API void RenderArrowDockMenu(ImDrawList* draw_list, ImVec2 p_min, float sz, ImU32 col);
3832	IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
3833	IMGUI_API void RenderRectFilledWithHole(ImDrawList* draw_list, const ImRect& outer, const ImRect& inner, ImU32 col, float rounding);
3834	IMGUI_API ImDrawFlags CalcRoundingFlagsForRectInRect(const ImRect& r_in, const ImRect& r_outer, float threshold);
3835
3836	// Widgets: Text
3837	IMGUI_API void TextEx(const char* text, const char* text_end = NULL, ImGuiTextFlags flags = 0);
3838	IMGUI_API void TextAligned(float align_x, float size_x, const char* fmt, ...); // FIXME-WIP: Works but API is likely to be reworked. This is designed for 1 item on the line. (#7024)
3839	IMGUI_API void TextAlignedV(float align_x, float size_x, const char* fmt, va_list args);
3840
3841	// Widgets
3842	IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
3843	IMGUI_API bool ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags = 0);
3844	IMGUI_API bool ImageButtonEx(ImGuiID id, ImTextureRef tex_ref, const ImVec2& image_size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& bg_col, const ImVec4& tint_col, ImGuiButtonFlags flags = 0);
3845	IMGUI_API void SeparatorEx(ImGuiSeparatorFlags flags, float thickness = 1.0f);
3846	IMGUI_API void SeparatorTextEx(ImGuiID id, const char* label, const char* label_end, float extra_width);
3847	IMGUI_API bool CheckboxFlags(const char* label, ImS64* flags, ImS64 flags_value);
3848	IMGUI_API bool CheckboxFlags(const char* label, ImU64* flags, ImU64 flags_value);
3849
3850	// Widgets: Window Decorations
3851	IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos);
3852	IMGUI_API bool CollapseButton(ImGuiID id, const ImVec2& pos, ImGuiDockNode* dock_node);
3853	IMGUI_API void Scrollbar(ImGuiAxis axis);
3854	IMGUI_API bool ScrollbarEx(const ImRect& bb, ImGuiID id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v, ImDrawFlags draw_rounding_flags = 0);
3855	IMGUI_API ImRect GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis);
3856	IMGUI_API ImGuiID GetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis);
3857	IMGUI_API ImGuiID GetWindowResizeCornerID(ImGuiWindow* window, int n); // 0..3: corners
3858	IMGUI_API ImGuiID GetWindowResizeBorderID(ImGuiWindow* window, ImGuiDir dir);
3859
3860	// Widgets low-level behaviors
3861	IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
3862	IMGUI_API bool DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags);
3863	IMGUI_API bool SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb);
3864	IMGUI_API bool SplitterBehavior(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f, float hover_visibility_delay = 0.0f, ImU32 bg_col = 0);
3865
3866	// Widgets: Tree Nodes
3867	IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
3868	IMGUI_API void TreeNodeDrawLineToChildNode(const ImVec2& target_pos);
3869	IMGUI_API void TreeNodeDrawLineToTreePop(const ImGuiTreeNodeStackData* data);
3870	IMGUI_API void TreePushOverrideID(ImGuiID id);
3871	IMGUI_API bool TreeNodeGetOpen(ImGuiID storage_id);
3872	IMGUI_API void TreeNodeSetOpen(ImGuiID storage_id, bool open);
3873	IMGUI_API bool TreeNodeUpdateNextOpen(ImGuiID storage_id, ImGuiTreeNodeFlags flags); // Return open state. Consume previous SetNextItemOpen() data, if any. May return true when logging.
3874
3875	// Template functions are instantiated in imgui_widgets.cpp for a finite number of types.
3876	// To use them externally (for custom widget) you may need an "extern template" statement in your code in order to link to existing instances and silence Clang warnings (see #2036).
3877	// e.g. " extern template IMGUI_API float RoundScalarWithFormatT<float, float>(const char* format, ImGuiDataType data_type, float v); "
3878	template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API float ScaleRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_size);
3879	template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API T ScaleValueFromRatioT(ImGuiDataType data_type, float t, T v_min, T v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_size);
3880	template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, T v_min, T v_max, const char* format, ImGuiSliderFlags flags);
3881	template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, T v_min, T v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb);
3882	template<typename T> IMGUI_API T RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, T v);
3883	template<typename T> IMGUI_API bool CheckboxFlagsT(const char* label, T* flags, T flags_value);
3884
3885	// Data type helpers
3886	IMGUI_API const ImGuiDataTypeInfo* DataTypeGetInfo(ImGuiDataType data_type);
3887	IMGUI_API int DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format);
3888	IMGUI_API void DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg_1, const void* arg_2);
3889	IMGUI_API bool DataTypeApplyFromText(const char* buf, ImGuiDataType data_type, void* p_data, const char* format, void* p_data_when_empty = NULL);
3890	IMGUI_API int DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2);
3891	IMGUI_API bool DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max);
3892	IMGUI_API bool DataTypeIsZero(ImGuiDataType data_type, const void* p_data);
3893
3894	// InputText
3895	IMGUI_API bool InputTextEx(const char* label, const char* hint, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
3896	IMGUI_API void InputTextDeactivateHook(ImGuiID id);
3897	IMGUI_API bool TempInputText(const ImRect& bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags);
3898	IMGUI_API bool TempInputScalar(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min = NULL, const void* p_clamp_max = NULL);
3899	inline bool TempInputIsActive(ImGuiID id) { ImGuiContext& g = *GImGui; return (g.ActiveId == id && g.TempInputId == id); }
3900	inline ImGuiInputTextState* GetInputTextState(ImGuiID id) { ImGuiContext& g = *GImGui; return (id != 0 && g.InputTextState.ID == id) ? &g.InputTextState : NULL; } // Get input text state if active
3901	IMGUI_API void SetNextItemRefVal(ImGuiDataType data_type, void* p_data);
3902	inline bool IsItemActiveAsInputText() { ImGuiContext& g = *GImGui; return g.ActiveId != 0 && g.ActiveId == g.LastItemData.ID && g.InputTextState.ID == g.LastItemData.ID; } // This may be useful to apply workaround that a based on distinguish whenever an item is active as a text input field.
3903
3904	// Color
3905	IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
3906	IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
3907	IMGUI_API void ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags);
3908
3909	// Plot
3910	IMGUI_API int PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, const ImVec2& size_arg);
3911
3912	// Shade functions (write over already created vertices)
3913	IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
3914	IMGUI_API void ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
3915	IMGUI_API void ShadeVertsTransformPos(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& pivot_in, float cos_a, float sin_a, const ImVec2& pivot_out);
3916
3917	// Garbage collection
3918	IMGUI_API void GcCompactTransientMiscBuffers();
3919	IMGUI_API void GcCompactTransientWindowBuffers(ImGuiWindow* window);
3920	IMGUI_API void GcAwakeTransientWindowBuffers(ImGuiWindow* window);
3921
3922	// Error handling, State Recovery
3923	IMGUI_API bool ErrorLog(const char* msg);
3924	IMGUI_API void ErrorRecoveryStoreState(ImGuiErrorRecoveryState* state_out);
3925	IMGUI_API void ErrorRecoveryTryToRecoverState(const ImGuiErrorRecoveryState* state_in);
3926	IMGUI_API void ErrorRecoveryTryToRecoverWindowState(const ImGuiErrorRecoveryState* state_in);
3927	IMGUI_API void ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
3928	IMGUI_API void ErrorCheckEndFrameFinalizeErrorTooltip();
3929	IMGUI_API bool BeginErrorTooltip();
3930	IMGUI_API void EndErrorTooltip();
3931
3932	// Debug Tools
3933	IMGUI_API void DebugAllocHook(ImGuiDebugAllocInfo* info, int frame_count, void* ptr, size_t size); // size >= 0 : alloc, size = -1 : free
3934	IMGUI_API void DebugDrawCursorPos(ImU32 col = IM_COL32(255, 0, 0, 255));
3935	IMGUI_API void DebugDrawLineExtents(ImU32 col = IM_COL32(255, 0, 0, 255));
3936	IMGUI_API void DebugDrawItemRect(ImU32 col = IM_COL32(255, 0, 0, 255));
3937	IMGUI_API void DebugTextUnformattedWithLocateItem(const char* line_begin, const char* line_end);
3938	IMGUI_API void DebugLocateItem(ImGuiID target_id); // Call sparingly: only 1 at the same time!
3939	IMGUI_API void DebugLocateItemOnHover(ImGuiID target_id); // Only call on reaction to a mouse Hover: because only 1 at the same time!
3940	IMGUI_API void DebugLocateItemResolveWithLastItem();
3941	IMGUI_API void DebugBreakClearData();
3942	IMGUI_API bool DebugBreakButton(const char* label, const char* description_of_location);
3943	IMGUI_API void DebugBreakButtonTooltip(bool keyboard_only, const char* description_of_location);
3944	IMGUI_API void ShowFontAtlas(ImFontAtlas* atlas);
3945	IMGUI_API void DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* data_id, const void* data_id_end);
3946	IMGUI_API void DebugNodeColumns(ImGuiOldColumns* columns);
3947	IMGUI_API void DebugNodeDockNode(ImGuiDockNode* node, const char* label);
3948	IMGUI_API void DebugNodeDrawList(ImGuiWindow* window, ImGuiViewportP* viewport, const ImDrawList* draw_list, const char* label);
3949	IMGUI_API void DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawList* out_draw_list, const ImDrawList* draw_list, const ImDrawCmd* draw_cmd, bool show_mesh, bool show_aabb);
3950	IMGUI_API void DebugNodeFont(ImFont* font);
3951	IMGUI_API void DebugNodeFontGlyphesForSrcMask(ImFont* font, ImFontBaked* baked, int src_mask);
3952	IMGUI_API void DebugNodeFontGlyph(ImFont* font, const ImFontGlyph* glyph);
3953	IMGUI_API void DebugNodeTexture(ImTextureData* tex, int int_id, const ImFontAtlasRect* highlight_rect = NULL); // ID used to facilitate persisting the "current" texture.
3954	IMGUI_API void DebugNodeStorage(ImGuiStorage* storage, const char* label);
3955	IMGUI_API void DebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label);
3956	IMGUI_API void DebugNodeTable(ImGuiTable* table);
3957	IMGUI_API void DebugNodeTableSettings(ImGuiTableSettings* settings);
3958	IMGUI_API void DebugNodeInputTextState(ImGuiInputTextState* state);
3959	IMGUI_API void DebugNodeTypingSelectState(ImGuiTypingSelectState* state);
3960	IMGUI_API void DebugNodeMultiSelectState(ImGuiMultiSelectState* state);
3961	IMGUI_API void DebugNodeWindow(ImGuiWindow* window, const char* label);
3962	IMGUI_API void DebugNodeWindowSettings(ImGuiWindowSettings* settings);
3963	IMGUI_API void DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label);
3964	IMGUI_API void DebugNodeWindowsListByBeginStackParent(ImGuiWindow** windows, int windows_size, ImGuiWindow* parent_in_begin_stack);
3965	IMGUI_API void DebugNodeViewport(ImGuiViewportP* viewport);
3966	IMGUI_API void DebugNodePlatformMonitor(ImGuiPlatformMonitor* monitor, const char* label, int idx);
3967	IMGUI_API void DebugRenderKeyboardPreview(ImDrawList* draw_list);
3968	IMGUI_API void DebugRenderViewportThumbnail(ImDrawList* draw_list, ImGuiViewportP* viewport, const ImRect& bb);
3969
3970	// Obsolete functions
3971	#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
3972	//inline void SetItemUsingMouseWheel() { SetItemKeyOwner(ImGuiKey_MouseWheelY); } // Changed in 1.89
3973	//inline bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0) { return TreeNodeUpdateNextOpen(id, flags); } // Renamed in 1.89
3974	//inline bool IsKeyPressedMap(ImGuiKey key, bool repeat = true) { IM_ASSERT(IsNamedKey(key)); return IsKeyPressed(key, repeat); } // Removed in 1.87: Mapping from named key is always identity!
3975
3976	// Refactored focus/nav/tabbing system in 1.82 and 1.84. If you have old/custom copy-and-pasted widgets which used FocusableItemRegister():
3977	// (Old) IMGUI_VERSION_NUM < 18209: using 'ItemAdd(....)' and 'bool tab_focused = FocusableItemRegister(...)'
3978	// (Old) IMGUI_VERSION_NUM >= 18209: using 'ItemAdd(..., ImGuiItemAddFlags_Focusable)' and 'bool tab_focused = (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_Focused) != 0'
3979	// (New) IMGUI_VERSION_NUM >= 18413: using 'ItemAdd(..., ImGuiItemFlags_Inputable)' and 'bool tab_focused = (g.NavActivateId == id && (g.NavActivateFlags & ImGuiActivateFlags_PreferInput))'
3980	//inline bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id) // -> pass ImGuiItemAddFlags_Inputable flag to ItemAdd()
3981	//inline void FocusableItemUnregister(ImGuiWindow* window) // -> unnecessary: TempInputText() uses ImGuiInputTextFlags_MergedItem
3982	#endif
3983
3984	} // namespace ImGui
3985
3986
3987	//-----------------------------------------------------------------------------
3988	// [SECTION] ImFontLoader
3989	//-----------------------------------------------------------------------------
3990
3991	// Hooks and storage for a given font backend.
3992	// This structure is likely to evolve as we add support for incremental atlas updates.
3993	// Conceptually this could be public, but API is still going to be evolve.
3994	struct ImFontLoader
3995	{
3996	const char* Name;
3997	bool (*LoaderInit)(ImFontAtlas* atlas);
3998	void (*LoaderShutdown)(ImFontAtlas* atlas);
3999	bool (*FontSrcInit)(ImFontAtlas* atlas, ImFontConfig* src);
4000	void (*FontSrcDestroy)(ImFontAtlas* atlas, ImFontConfig* src);
4001	bool (*FontSrcContainsGlyph)(ImFontAtlas* atlas, ImFontConfig* src, ImWchar codepoint);
4002	bool (*FontBakedInit)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src);
4003	void (*FontBakedDestroy)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src);
4004	bool (*FontBakedLoadGlyph)(ImFontAtlas* atlas, ImFontConfig* src, ImFontBaked* baked, void* loader_data_for_baked_src, ImWchar codepoint, ImFontGlyph* out_glyph, float* out_advance_x);
4005
4006	// Size of backend data, Per Baked * Per Source. Buffers are managed by core to avoid excessive allocations.
4007	// FIXME: At this point the two other types of buffers may be managed by core to be consistent?
4008	size_t FontBakedSrcLoaderDataSize;
4009
4010	ImFontLoader() { memset(s: this, c: 0, n: sizeof(*this)); }
4011	};
4012
4013	#ifdef IMGUI_ENABLE_STB_TRUETYPE
4014	IMGUI_API const ImFontLoader* ImFontAtlasGetFontLoaderForStbTruetype();
4015	#endif
4016	#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
4017	typedef ImFontLoader ImFontBuilderIO; // [renamed/changed in 1.92] The types are not actually compatible but we provide this as a compile-time error report helper.
4018	#endif
4019
4020	//-----------------------------------------------------------------------------
4021	// [SECTION] ImFontAtlas internal API
4022	//-----------------------------------------------------------------------------
4023
4024	#define IMGUI_FONT_SIZE_MAX (512.0f)
4025	#define IMGUI_FONT_SIZE_THRESHOLD_FOR_LOADADVANCEXONLYMODE (128.0f)
4026
4027	// Helpers: ImTextureRef ==/!= operators provided as convenience
4028	// (note that _TexID and _TexData are never set simultaneously)
4029	inline bool operator==(const ImTextureRef& lhs, const ImTextureRef& rhs) { return lhs._TexID == rhs._TexID && lhs._TexData == rhs._TexData; }
4030	inline bool operator!=(const ImTextureRef& lhs, const ImTextureRef& rhs) { return lhs._TexID != rhs._TexID || lhs._TexData != rhs._TexData; }
4031
4032	// Refer to ImFontAtlasPackGetRect() to better understand how this works.
4033	#define ImFontAtlasRectId_IndexMask_ (0x000FFFFF) // 20-bits: index to access builder->RectsIndex[].
4034	#define ImFontAtlasRectId_GenerationMask_ (0x3FF00000) // 10-bits: entry generation, so each ID is unique and get can safely detected old identifiers.
4035	#define ImFontAtlasRectId_GenerationShift_ (20)
4036	inline int ImFontAtlasRectId_GetIndex(ImFontAtlasRectId id) { return id & ImFontAtlasRectId_IndexMask_; }
4037	inline int ImFontAtlasRectId_GetGeneration(ImFontAtlasRectId id) { return (id & ImFontAtlasRectId_GenerationMask_) >> ImFontAtlasRectId_GenerationShift_; }
4038	inline ImFontAtlasRectId ImFontAtlasRectId_Make(int index_idx, int gen_idx) { IM_ASSERT(index_idx < ImFontAtlasRectId_IndexMask_ && gen_idx < (ImFontAtlasRectId_GenerationMask_ >> ImFontAtlasRectId_GenerationShift_)); return (ImFontAtlasRectId)(index_idx | (gen_idx << ImFontAtlasRectId_GenerationShift_)); }
4039
4040	// Packed rectangle lookup entry (we need an indirection to allow removing/reordering rectangles)
4041	// User are returned ImFontAtlasRectId values which are meant to be persistent.
4042	// We handle this with an indirection. While Rects[] may be in theory shuffled, compacted etc., RectsIndex[] cannot it is keyed by ImFontAtlasRectId.
4043	// RectsIndex[] is used both as an index into Rects[] and an index into itself. This is basically a free-list. See ImFontAtlasBuildAllocRectIndexEntry() code.
4044	// Having this also makes it easier to e.g. sort rectangles during repack.
4045	struct ImFontAtlasRectEntry
4046	{
4047	int TargetIndex : 20; // When Used: ImFontAtlasRectId -> into Rects[]. When unused: index to next unused RectsIndex[] slot to consume free-list.
4048	int Generation : 10; // Increased each time the entry is reused for a new rectangle.
4049	unsigned int IsUsed : 1;
4050	};
4051
4052	// Data available to potential texture post-processing functions
4053	struct ImFontAtlasPostProcessData
4054	{
4055	ImFontAtlas* FontAtlas;
4056	ImFont* Font;
4057	ImFontConfig* FontSrc;
4058	ImFontBaked* FontBaked;
4059	ImFontGlyph* Glyph;
4060
4061	// Pixel data
4062	void* Pixels;
4063	ImTextureFormat Format;
4064	int Pitch;
4065	int Width;
4066	int Height;
4067	};
4068
4069	// We avoid dragging imstb_rectpack.h into public header (partly because binding generators are having issues with it)
4070	#ifdef IMGUI_STB_NAMESPACE
4071	namespace IMGUI_STB_NAMESPACE { struct stbrp_node; }
4072	typedef IMGUI_STB_NAMESPACE::stbrp_node stbrp_node_im;
4073	#else
4074	struct stbrp_node;
4075	typedef stbrp_node stbrp_node_im;
4076	#endif
4077	struct stbrp_context_opaque { char data[80]; };
4078
4079	// Internal storage for incrementally packing and building a ImFontAtlas
4080	struct ImFontAtlasBuilder
4081	{
4082	stbrp_context_opaque PackContext; // Actually 'stbrp_context' but we don't want to define this in the header file.
4083	ImVector<stbrp_node_im> PackNodes;
4084	ImVector<ImTextureRect> Rects;
4085	ImVector<ImFontAtlasRectEntry> RectsIndex; // ImFontAtlasRectId -> index into Rects[]
4086	ImVector<unsigned char> TempBuffer; // Misc scratch buffer
4087	int RectsIndexFreeListStart;// First unused entry
4088	int RectsPackedCount; // Number of packed rectangles.
4089	int RectsPackedSurface; // Number of packed pixels. Used when compacting to heuristically find the ideal texture size.
4090	int RectsDiscardedCount;
4091	int RectsDiscardedSurface;
4092	int FrameCount; // Current frame count
4093	ImVec2i MaxRectSize; // Largest rectangle to pack (de-facto used as a "minimum texture size")
4094	ImVec2i MaxRectBounds; // Bottom-right most used pixels
4095	bool LockDisableResize; // Disable resizing texture
4096	bool PreloadedAllGlyphsRanges; // Set when missing ImGuiBackendFlags_RendererHasTextures features forces atlas to preload everything.
4097
4098	// Cache of all ImFontBaked
4099	ImStableVector<ImFontBaked,32> BakedPool;
4100	ImGuiStorage BakedMap; // BakedId --> ImFontBaked*
4101	int BakedDiscardedCount;
4102
4103	// Custom rectangle identifiers
4104	ImFontAtlasRectId PackIdMouseCursors; // White pixel + mouse cursors. Also happen to be fallback in case of packing failure.
4105	ImFontAtlasRectId PackIdLinesTexData;
4106
4107	ImFontAtlasBuilder() { memset(s: this, c: 0, n: sizeof(*this)); FrameCount = -1; RectsIndexFreeListStart = -1; PackIdMouseCursors = PackIdLinesTexData = -1; }
4108	};
4109
4110	IMGUI_API void ImFontAtlasBuildInit(ImFontAtlas* atlas);
4111	IMGUI_API void ImFontAtlasBuildDestroy(ImFontAtlas* atlas);
4112	IMGUI_API void ImFontAtlasBuildMain(ImFontAtlas* atlas);
4113	IMGUI_API void ImFontAtlasBuildSetupFontLoader(ImFontAtlas* atlas, const ImFontLoader* font_loader);
4114	IMGUI_API void ImFontAtlasBuildUpdatePointers(ImFontAtlas* atlas);
4115	IMGUI_API void ImFontAtlasBuildRenderBitmapFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char);
4116	IMGUI_API void ImFontAtlasBuildClear(ImFontAtlas* atlas); // Clear output and custom rects
4117
4118	IMGUI_API ImTextureData* ImFontAtlasTextureAdd(ImFontAtlas* atlas, int w, int h);
4119	IMGUI_API void ImFontAtlasTextureMakeSpace(ImFontAtlas* atlas);
4120	IMGUI_API void ImFontAtlasTextureRepack(ImFontAtlas* atlas, int w, int h);
4121	IMGUI_API void ImFontAtlasTextureGrow(ImFontAtlas* atlas, int old_w = -1, int old_h = -1);
4122	IMGUI_API void ImFontAtlasTextureCompact(ImFontAtlas* atlas);
4123	IMGUI_API ImVec2i ImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas);
4124
4125	IMGUI_API void ImFontAtlasBuildSetupFontSpecialGlyphs(ImFontAtlas* atlas, ImFont* font, ImFontConfig* src);
4126	IMGUI_API void ImFontAtlasBuildLegacyPreloadAllGlyphRanges(ImFontAtlas* atlas); // Legacy
4127	IMGUI_API void ImFontAtlasBuildGetOversampleFactors(ImFontConfig* src, ImFontBaked* baked, int* out_oversample_h, int* out_oversample_v);
4128	IMGUI_API void ImFontAtlasBuildDiscardBakes(ImFontAtlas* atlas, int unused_frames);
4129
4130	IMGUI_API bool ImFontAtlasFontSourceInit(ImFontAtlas* atlas, ImFontConfig* src);
4131	IMGUI_API void ImFontAtlasFontSourceAddToFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* src);
4132	IMGUI_API void ImFontAtlasFontDestroySourceData(ImFontAtlas* atlas, ImFontConfig* src);
4133	IMGUI_API bool ImFontAtlasFontInitOutput(ImFontAtlas* atlas, ImFont* font); // Using FontDestroyOutput/FontInitOutput sequence useful notably if font loader params have changed
4134	IMGUI_API void ImFontAtlasFontDestroyOutput(ImFontAtlas* atlas, ImFont* font);
4135	IMGUI_API void ImFontAtlasFontDiscardBakes(ImFontAtlas* atlas, ImFont* font, int unused_frames);
4136
4137	IMGUI_API ImGuiID ImFontAtlasBakedGetId(ImGuiID font_id, float baked_size, float rasterizer_density);
4138	IMGUI_API ImFontBaked* ImFontAtlasBakedGetOrAdd(ImFontAtlas* atlas, ImFont* font, float font_size, float font_rasterizer_density);
4139	IMGUI_API ImFontBaked* ImFontAtlasBakedGetClosestMatch(ImFontAtlas* atlas, ImFont* font, float font_size, float font_rasterizer_density);
4140	IMGUI_API ImFontBaked* ImFontAtlasBakedAdd(ImFontAtlas* atlas, ImFont* font, float font_size, float font_rasterizer_density, ImGuiID baked_id);
4141	IMGUI_API void ImFontAtlasBakedDiscard(ImFontAtlas* atlas, ImFont* font, ImFontBaked* baked);
4142	IMGUI_API ImFontGlyph* ImFontAtlasBakedAddFontGlyph(ImFontAtlas* atlas, ImFontBaked* baked, ImFontConfig* src, const ImFontGlyph* in_glyph);
4143	IMGUI_API void ImFontAtlasBakedAddFontGlyphAdvancedX(ImFontAtlas* atlas, ImFontBaked* baked, ImFontConfig* src, ImWchar codepoint, float advance_x);
4144	IMGUI_API void ImFontAtlasBakedDiscardFontGlyph(ImFontAtlas* atlas, ImFont* font, ImFontBaked* baked, ImFontGlyph* glyph);
4145	IMGUI_API void ImFontAtlasBakedSetFontGlyphBitmap(ImFontAtlas* atlas, ImFontBaked* baked, ImFontConfig* src, ImFontGlyph* glyph, ImTextureRect* r, const unsigned char* src_pixels, ImTextureFormat src_fmt, int src_pitch);
4146
4147	IMGUI_API void ImFontAtlasPackInit(ImFontAtlas* atlas);
4148	IMGUI_API ImFontAtlasRectId ImFontAtlasPackAddRect(ImFontAtlas* atlas, int w, int h, ImFontAtlasRectEntry* overwrite_entry = NULL);
4149	IMGUI_API ImTextureRect* ImFontAtlasPackGetRect(ImFontAtlas* atlas, ImFontAtlasRectId id);
4150	IMGUI_API ImTextureRect* ImFontAtlasPackGetRectSafe(ImFontAtlas* atlas, ImFontAtlasRectId id);
4151	IMGUI_API void ImFontAtlasPackDiscardRect(ImFontAtlas* atlas, ImFontAtlasRectId id);
4152
4153	IMGUI_API void ImFontAtlasUpdateNewFrame(ImFontAtlas* atlas, int frame_count, bool renderer_has_textures);
4154	IMGUI_API void ImFontAtlasAddDrawListSharedData(ImFontAtlas* atlas, ImDrawListSharedData* data);
4155	IMGUI_API void ImFontAtlasRemoveDrawListSharedData(ImFontAtlas* atlas, ImDrawListSharedData* data);
4156	IMGUI_API void ImFontAtlasUpdateDrawListsTextures(ImFontAtlas* atlas, ImTextureRef old_tex, ImTextureRef new_tex);
4157	IMGUI_API void ImFontAtlasUpdateDrawListsSharedData(ImFontAtlas* atlas);
4158
4159	IMGUI_API void ImFontAtlasTextureBlockConvert(const unsigned char* src_pixels, ImTextureFormat src_fmt, int src_pitch, unsigned char* dst_pixels, ImTextureFormat dst_fmt, int dst_pitch, int w, int h);
4160	IMGUI_API void ImFontAtlasTextureBlockPostProcess(ImFontAtlasPostProcessData* data);
4161	IMGUI_API void ImFontAtlasTextureBlockPostProcessMultiply(ImFontAtlasPostProcessData* data, float multiply_factor);
4162	IMGUI_API void ImFontAtlasTextureBlockFill(ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h, ImU32 col);
4163	IMGUI_API void ImFontAtlasTextureBlockCopy(ImTextureData* src_tex, int src_x, int src_y, ImTextureData* dst_tex, int dst_x, int dst_y, int w, int h);
4164	IMGUI_API void ImFontAtlasTextureBlockQueueUpload(ImFontAtlas* atlas, ImTextureData* tex, int x, int y, int w, int h);
4165
4166	IMGUI_API int ImTextureDataGetFormatBytesPerPixel(ImTextureFormat format);
4167	IMGUI_API const char* ImTextureDataGetStatusName(ImTextureStatus status);
4168	IMGUI_API const char* ImTextureDataGetFormatName(ImTextureFormat format);
4169
4170	#ifndef IMGUI_DISABLE_DEBUG_TOOLS
4171	IMGUI_API void ImFontAtlasDebugLogTextureRequests(ImFontAtlas* atlas);
4172	#endif
4173
4174	IMGUI_API bool ImFontAtlasGetMouseCursorTexData(ImFontAtlas* atlas, ImGuiMouseCursor cursor_type, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2]);
4175
4176	//-----------------------------------------------------------------------------
4177	// [SECTION] Test Engine specific hooks (imgui_test_engine)
4178	//-----------------------------------------------------------------------------
4179
4180	#ifdef IMGUI_ENABLE_TEST_ENGINE
4181	extern void ImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, ImGuiID id, const ImRect& bb, const ImGuiLastItemData* item_data); // item_data may be NULL
4182	extern void ImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags);
4183	extern void ImGuiTestEngineHook_Log(ImGuiContext* ctx, const char* fmt, ...);
4184	extern const char* ImGuiTestEngine_FindItemDebugLabel(ImGuiContext* ctx, ImGuiID id);
4185
4186	// In IMGUI_VERSION_NUM >= 18934: changed IMGUI_TEST_ENGINE_ITEM_ADD(bb,id) to IMGUI_TEST_ENGINE_ITEM_ADD(id,bb,item_data);
4187	#define IMGUI_TEST_ENGINE_ITEM_ADD(_ID,_BB,_ITEM_DATA) if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemAdd(&g, _ID, _BB, _ITEM_DATA) // Register item bounding box
4188	#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS) if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS) // Register item label and status flags (optional)
4189	#define IMGUI_TEST_ENGINE_LOG(_FMT,...) ImGuiTestEngineHook_Log(&g, _FMT, __VA_ARGS__) // Custom log entry from user land into test log
4190	#else
4191	#define IMGUI_TEST_ENGINE_ITEM_ADD(_BB,_ID) ((void)0)
4192	#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS) ((void)g)
4193	#endif
4194
4195	//-----------------------------------------------------------------------------
4196
4197	#if defined(__clang__)
4198	#pragma clang diagnostic pop
4199	#elif defined(__GNUC__)
4200	#pragma GCC diagnostic pop
4201	#endif
4202
4203	#ifdef _MSC_VER
4204	#pragma warning (pop)
4205	#endif
4206
4207	#endif // #ifndef IMGUI_DISABLE
4208