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