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