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
8Index 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
122struct ImBitVector; // Store 1-bit per value
123struct ImRect; // An axis-aligned rectangle (2 points)
124struct ImDrawDataBuilder; // Helper to build a ImDrawData instance
125struct ImDrawListSharedData; // Data shared between all ImDrawList instances
126struct ImGuiColorMod; // Stacked color modifier, backup of modified data so we can restore it
127struct ImGuiContext; // Main Dear ImGui context
128struct ImGuiContextHook; // Hook for extensions like ImGuiTestEngine
129struct ImGuiDataVarInfo; // Variable information (e.g. to avoid style variables from an enum)
130struct ImGuiDataTypeInfo; // Type information associated to a ImGuiDataType enum
131struct ImGuiDockContext; // Docking system context
132struct ImGuiDockRequest; // Docking system dock/undock queued request
133struct ImGuiDockNode; // Docking system node (hold a list of Windows OR two child dock nodes)
134struct ImGuiDockNodeSettings; // Storage for a dock node in .ini file (we preserve those even if the associated dock node isn't active during the session)
135struct ImGuiGroupData; // Stacked storage data for BeginGroup()/EndGroup()
136struct ImGuiInputTextState; // Internal state of the currently focused/edited text input box
137struct ImGuiInputTextDeactivateData;// Short term storage to backup text of a deactivating InputText() while another is stealing active id
138struct ImGuiLastItemData; // Status storage for last submitted items
139struct ImGuiLocEntry; // A localization entry.
140struct ImGuiMenuColumns; // Simple column measurement, currently used for MenuItem() only
141struct ImGuiNavItemData; // Result of a gamepad/keyboard directional navigation move query result
142struct ImGuiNavTreeNodeData; // Temporary storage for last TreeNode() being a Left arrow landing candidate.
143struct ImGuiMetricsConfig; // Storage for ShowMetricsWindow() and DebugNodeXXX() functions
144struct ImGuiNextWindowData; // Storage for SetNextWindow** functions
145struct ImGuiNextItemData; // Storage for SetNextItem** functions
146struct ImGuiOldColumnData; // Storage data for a single column for legacy Columns() api
147struct ImGuiOldColumns; // Storage data for a columns set for legacy Columns() api
148struct ImGuiPopupData; // Storage for current popup stack
149struct ImGuiSettingsHandler; // Storage for one type registered in the .ini file
150struct ImGuiStackSizes; // Storage of stack sizes for debugging/asserting
151struct ImGuiStyleMod; // Stacked style modifier, backup of modified data so we can restore it
152struct ImGuiTabBar; // Storage for a tab bar
153struct ImGuiTabItem; // Storage for a tab item (within a tab bar)
154struct ImGuiTable; // Storage for a table
155struct ImGuiTableColumn; // Storage for one column of a table
156struct ImGuiTableInstanceData; // Storage for one instance of a same table
157struct ImGuiTableTempData; // Temporary storage for one table (one per table in the stack), shared between tables.
158struct ImGuiTableSettings; // Storage for a table .ini settings
159struct ImGuiTableColumnsSettings; // Storage for a column .ini settings
160struct ImGuiTypingSelectState; // Storage for GetTypingSelectRequest()
161struct ImGuiTypingSelectRequest; // Storage for GetTypingSelectRequest() (aimed to be public)
162struct ImGuiWindow; // Storage for one window
163struct 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)
164struct 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.
168enum ImGuiLocKey : int; // -> enum ImGuiLocKey // Enum: a localization entry for translation.
169typedef int ImGuiDataAuthority; // -> enum ImGuiDataAuthority_ // Enum: for storing the source authority (dock node vs window) of a field
170typedef int ImGuiLayoutType; // -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical
171
172// Flags
173typedef int ImGuiActivateFlags; // -> enum ImGuiActivateFlags_ // Flags: for navigation/focus function (will be for ActivateItem() later)
174typedef int ImGuiDebugLogFlags; // -> enum ImGuiDebugLogFlags_ // Flags: for ShowDebugLogWindow(), g.DebugLogFlags
175typedef int ImGuiFocusRequestFlags; // -> enum ImGuiFocusRequestFlags_ // Flags: for FocusWindow();
176typedef int ImGuiInputFlags; // -> enum ImGuiInputFlags_ // Flags: for IsKeyPressed(), IsMouseClicked(), SetKeyOwner(), SetItemKeyOwner() etc.
177typedef int ImGuiItemFlags; // -> enum ImGuiItemFlags_ // Flags: for PushItemFlag(), g.LastItemData.InFlags
178typedef int ImGuiItemStatusFlags; // -> enum ImGuiItemStatusFlags_ // Flags: for g.LastItemData.StatusFlags
179typedef int ImGuiOldColumnFlags; // -> enum ImGuiOldColumnFlags_ // Flags: for BeginColumns()
180typedef int ImGuiNavHighlightFlags; // -> enum ImGuiNavHighlightFlags_ // Flags: for RenderNavHighlight()
181typedef int ImGuiNavMoveFlags; // -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests
182typedef int ImGuiNextItemDataFlags; // -> enum ImGuiNextItemDataFlags_ // Flags: for SetNextItemXXX() functions
183typedef int ImGuiNextWindowDataFlags; // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions
184typedef int ImGuiScrollFlags; // -> enum ImGuiScrollFlags_ // Flags: for ScrollToItem() and navigation requests
185typedef int ImGuiSeparatorFlags; // -> enum ImGuiSeparatorFlags_ // Flags: for SeparatorEx()
186typedef int ImGuiTextFlags; // -> enum ImGuiTextFlags_ // Flags: for TextEx()
187typedef int ImGuiTooltipFlags; // -> enum ImGuiTooltipFlags_ // Flags: for BeginTooltipEx()
188typedef int ImGuiTypingSelectFlags; // -> enum ImGuiTypingSelectFlags_ // Flags: for GetTypingSelectRequest()
189
190typedef 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
198extern IMGUI_API ImGuiContext* GImGui; // Current implicit context pointer
199#endif
200
201//-------------------------------------------------------------------------
202// [SECTION] STB libraries includes
203//-------------------------------------------------------------------------
204
205namespace 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
363IMGUI_API ImGuiID ImHashData(const void* data, size_t data_size, ImGuiID seed = 0);
364IMGUI_API ImGuiID ImHashStr(const char* data, size_t data_size = 0, ImGuiID seed = 0);
365
366// Helpers: Sorting
367#ifndef ImQsort
368static 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
372IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);
373
374// Helpers: Bit manipulation
375static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
376static inline bool ImIsPowerOfTwo(ImU64 v) { return v != 0 && (v & (v - 1)) == 0; }
377static 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
380IMGUI_API int ImStricmp(const char* str1, const char* str2); // Case insensitive compare.
381IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count); // Case insensitive compare to a certain count.
382IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count); // Copy to a certain count and always zero terminate (strncpy doesn't).
383IMGUI_API char* ImStrdup(const char* str); // Duplicate a string.
384IMGUI_API char* ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str); // Copy in provided buffer, recreate buffer if needed.
385IMGUI_API const char* ImStrchrRange(const char* str_begin, const char* str_end, char c); // Find first occurrence of 'c' in string range.
386IMGUI_API const char* ImStreolRange(const char* str, const char* str_end); // End end-of-line
387IMGUI_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.
388IMGUI_API void ImStrTrimBlanks(char* str); // Remove leading and trailing blanks from a buffer.
389IMGUI_API const char* ImStrSkipBlank(const char* str); // Find first non-blank character.
390IMGUI_API int ImStrlenW(const ImWchar* str); // Computer string length (ImWchar string)
391IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line (ImWchar string)
392IM_MSVC_RUNTIME_CHECKS_OFF
393static inline char ImToUpper(char c) { return (c >= 'a' && c <= 'z') ? c &= ~32 : c; }
394static inline bool ImCharIsBlankA(char c) { return c == ' ' || c == '\t'; }
395static inline bool ImCharIsBlankW(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
396IM_MSVC_RUNTIME_CHECKS_RESTORE
397
398// Helpers: Formatting
399IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
400IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
401IMGUI_API void ImFormatStringToTempBuffer(const char** out_buf, const char** out_buf_end, const char* fmt, ...) IM_FMTARGS(3);
402IMGUI_API void ImFormatStringToTempBufferV(const char** out_buf, const char** out_buf_end, const char* fmt, va_list args) IM_FMTLIST(3);
403IMGUI_API const char* ImParseFormatFindStart(const char* format);
404IMGUI_API const char* ImParseFormatFindEnd(const char* format);
405IMGUI_API const char* ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);
406IMGUI_API void ImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out, size_t fmt_out_size);
407IMGUI_API const char* ImParseFormatSanitizeForScanning(const char* fmt_in, char* fmt_out, size_t fmt_out_size);
408IMGUI_API int ImParseFormatPrecision(const char* format, int default_value);
409
410// Helpers: UTF-8 <> wchar conversions
411IMGUI_API const char* ImTextCharToUtf8(char out_buf[5], unsigned int c); // return out_buf
412IMGUI_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
413IMGUI_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
414IMGUI_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
415IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count)
416IMGUI_API int ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end); // return number of bytes to express one char in UTF-8
417IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string in UTF-8
418IMGUI_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
423typedef void* ImFileHandle;
424static inline ImFileHandle ImFileOpen(const char*, const char*) { return NULL; }
425static inline bool ImFileClose(ImFileHandle) { return false; }
426static inline ImU64 ImFileGetSize(ImFileHandle) { return (ImU64)-1; }
427static inline ImU64 ImFileRead(void*, ImU64, ImU64, ImFileHandle) { return 0; }
428static inline ImU64 ImFileWrite(const void*, ImU64, ImU64, ImFileHandle) { return 0; }
429#endif
430#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
431typedef FILE* ImFileHandle;
432IMGUI_API ImFileHandle ImFileOpen(const char* filename, const char* mode);
433IMGUI_API bool ImFileClose(ImFileHandle file);
434IMGUI_API ImU64 ImFileGetSize(ImFileHandle file);
435IMGUI_API ImU64 ImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file);
436IMGUI_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
440IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size = NULL, int padding_bytes = 0);
441
442// Helpers: Maths
443IM_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)
455static 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
456static inline double ImPow(double x, double y) { return pow(x: x, y: y); }
457static inline float ImLog(float x) { return logf(x: x); } // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision
458static inline double ImLog(double x) { return log(x: x); }
459static inline int ImAbs(int x) { return x < 0 ? -x : x; }
460static inline float ImAbs(float x) { return fabsf(x: x); }
461static inline double ImAbs(double x) { return fabs(x: x); }
462static 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
463static inline double ImSign(double x) { return (x < 0.0) ? -1.0 : (x > 0.0) ? 1.0 : 0.0; }
464#ifdef IMGUI_ENABLE_SSE
465static inline float ImRsqrt(float x) { return _mm_cvtss_f32(a: _mm_rsqrt_ss(a: _mm_set_ss(w: x))); }
466#else
467static inline float ImRsqrt(float x) { return 1.0f / sqrtf(x); }
468#endif
469static 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)
473template<typename T> static inline T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; }
474template<typename T> static inline T ImMax(T lhs, T rhs) { return lhs >= rhs ? lhs : rhs; }
475template<typename T> static inline T ImClamp(T v, T mn, T mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
476template<typename T> static inline T ImLerp(T a, T b, float t) { return (T)(a + (b - a) * t); }
477template<typename T> static inline void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
478template<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; }
479template<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
481static 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); }
482static 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); }
483static 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); }
484static 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); }
485static 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); }
486static 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); }
487static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
488static inline float ImLengthSqr(const ImVec2& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y); }
489static inline float ImLengthSqr(const ImVec4& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y) + (lhs.z * lhs.z) + (lhs.w * lhs.w); }
490static 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; }
491static inline float ImTrunc(float f) { return (float)(int)(f); }
492static inline ImVec2 ImTrunc(const ImVec2& v) { return ImVec2((float)(int)(v.x), (float)(int)(v.y)); }
493static inline float ImFloor(float f) { return (float)((f >= 0 || (float)(int)f == f) ? (int)f : (int)f - 1); } // Decent replacement for floorf()
494static inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2(ImFloor(f: v.x), ImFloor(f: v.y)); }
495static inline int ImModPositive(int a, int b) { return (a + b) % b; }
496static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }
497static 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); }
498static 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; }
499static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
500static inline bool ImIsFloatAboveGuaranteedIntegerPrecision(float f) { return f <= -16777216 || f >= 16777216; }
501static inline float ImExponentialMovingAverage(float avg, float sample, int n) { avg -= avg / n; avg += sample / n; return avg; }
502IM_MSVC_RUNTIME_CHECKS_RESTORE
503
504// Helpers: Geometry
505IMGUI_API ImVec2 ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t);
506IMGUI_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
507IMGUI_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
508IMGUI_API ImVec2 ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t);
509IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
510IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
511IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
512IMGUI_API void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
513inline 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; }
514inline 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)
518IM_MSVC_RUNTIME_CHECKS_OFF
519struct 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)
527struct 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!
537struct 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!
577inline size_t ImBitArrayGetStorageSizeInBytes(int bitcount) { return (size_t)((bitcount + 31) >> 5) << 2; }
578inline void ImBitArrayClearAllBits(ImU32* arr, int bitcount){ memset(s: arr, c: 0, n: ImBitArrayGetStorageSizeInBytes(bitcount)); }
579inline bool ImBitArrayTestBit(const ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); return (arr[n >> 5] & mask) != 0; }
580inline void ImBitArrayClearBit(ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] &= ~mask; }
581inline void ImBitArraySetBit(ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] |= mask; }
582inline 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
595typedef ImU32* ImBitArrayPtr; // Name for use in structs
596
597// Helper: ImBitArray class (wrapper over ImBitArray functions)
598// Store 1-bit per value.
599template<int BITCOUNT, int OFFSET = 0>
600struct 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.
615struct 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};
624IM_MSVC_RUNTIME_CHECKS_RESTORE
625
626// Helper: ImSpan<>
627// Pointing to a span of data we don't own.
628template<typename T>
629struct 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.
658template<int CHUNKS>
659struct 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.
680typedef int ImPoolIdx;
681template<typename T>
682struct 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.
715template<typename T>
716struct 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.
735struct 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.
778struct 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
801struct 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.
818enum 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
840enum 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_
865enum 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_
873enum 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_
883enum 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_
908enum ImGuiComboFlagsPrivate_
909{
910 ImGuiComboFlags_CustomPreview = 1 << 20, // enable BeginComboPreview()
911};
912
913// Extend ImGuiSliderFlags_
914enum 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_
921enum 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_
935enum 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
941enum 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.
952enum 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
959enum ImGuiTextFlags_
960{
961 ImGuiTextFlags_None = 0,
962 ImGuiTextFlags_NoWidthForLargeClippedText = 1 << 0,
963};
964
965enum 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
973enum ImGuiLayoutType_
974{
975 ImGuiLayoutType_Horizontal = 0,
976 ImGuiLayoutType_Vertical = 1
977};
978
979enum 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
989enum ImGuiAxis
990{
991 ImGuiAxis_None = -1,
992 ImGuiAxis_X = 0,
993 ImGuiAxis_Y = 1
994};
995
996enum ImGuiPlotType
997{
998 ImGuiPlotType_Lines,
999 ImGuiPlotType_Histogram,
1000};
1001
1002// Stacked color modifier, backup of modified data so we can restore it
1003struct 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.
1010struct 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()
1020struct 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()
1033struct 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.
1051struct 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.
1069struct 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()
1079struct 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
1128enum 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
1146struct 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.)
1176typedef ImS64 ImGuiSelectionUserData;
1177
1178enum ImGuiNextItemDataFlags_
1179{
1180 ImGuiNextItemDataFlags_None = 0,
1181 ImGuiNextItemDataFlags_HasWidth = 1 << 0,
1182 ImGuiNextItemDataFlags_HasOpen = 1 << 1,
1183 ImGuiNextItemDataFlags_HasShortcut = 1 << 2,
1184};
1185
1186struct 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
1202struct 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.
1219struct ImGuiNavTreeNodeData
1220{
1221 ImGuiID ID;
1222 ImGuiItemFlags InFlags;
1223 ImRect NavRect;
1224};
1225
1226struct 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
1244struct ImGuiWindowStackData
1245{
1246 ImGuiWindow* Window;
1247 ImGuiLastItemData ParentLastItemDataBackup;
1248 ImGuiStackSizes StackSizesOnBegin; // Store size of various stacks for asserting
1249};
1250
1251struct ImGuiShrinkWidthItem
1252{
1253 int Index;
1254 float Width;
1255 float InitialWidth;
1256};
1257
1258struct 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
1271struct 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
1279struct 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().
1285struct 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_
1294enum ImGuiDataTypePrivate_
1295{
1296 ImGuiDataType_String = ImGuiDataType_COUNT + 1,
1297 ImGuiDataType_Pointer,
1298 ImGuiDataType_ID,
1299};
1300
1301//-----------------------------------------------------------------------------
1302// [SECTION] Popup support
1303//-----------------------------------------------------------------------------
1304
1305enum ImGuiPopupPositionPolicy
1306{
1307 ImGuiPopupPositionPolicy_Default,
1308 ImGuiPopupPositionPolicy_ComboBox,
1309 ImGuiPopupPositionPolicy_Tooltip,
1310};
1311
1312// Storage for popup stacks (g.OpenPopupStack and g.BeginPopupStack)
1313struct 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
1332typedef 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
1356enum 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
1369enum 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'
1380struct ImGuiInputEventMousePos { float PosX, PosY; ImGuiMouseSource MouseSource; };
1381struct ImGuiInputEventMouseWheel { float WheelX, WheelY; ImGuiMouseSource MouseSource; };
1382struct ImGuiInputEventMouseButton { int Button; bool Down; ImGuiMouseSource MouseSource; };
1383struct ImGuiInputEventMouseViewport { ImGuiID HoveredViewportID; };
1384struct ImGuiInputEventKey { ImGuiKey Key; bool Down; float AnalogValue; };
1385struct ImGuiInputEventText { unsigned int Char; };
1386struct ImGuiInputEventAppFocused { bool Focused; };
1387
1388struct 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
1412typedef ImS16 ImGuiKeyRoutingIndex;
1413
1414// Routing table entry (sizeof() == 16 bytes)
1415struct 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)
1429struct 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.
1441struct 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)
1453enum 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.
1524struct 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
1537struct 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
1553enum 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()
1564enum 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
1578enum 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
1586enum 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
1608enum ImGuiNavLayer
1609{
1610 ImGuiNavLayer_Main = 0, // Main scrolling layer
1611 ImGuiNavLayer_Menu = 1, // Menu layer (access with Alt)
1612 ImGuiNavLayer_COUNT
1613};
1614
1615struct 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
1631struct ImGuiFocusScopeData
1632{
1633 ImGuiID ID;
1634 ImGuiID WindowID;
1635};
1636
1637//-----------------------------------------------------------------------------
1638// [SECTION] Typing-select support
1639//-----------------------------------------------------------------------------
1640
1641// Flags for GetTypingSelectRequest()
1642enum 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.
1650struct 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()
1661struct 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!
1679enum 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
1699struct 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
1709struct 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_
1751enum 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
1780enum ImGuiDataAuthority_
1781{
1782 ImGuiDataAuthority_Auto,
1783 ImGuiDataAuthority_DockNode,
1784 ImGuiDataAuthority_Window,
1785};
1786
1787enum ImGuiDockNodeState
1788{
1789 ImGuiDockNodeState_Unknown,
1790 ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow,
1791 ImGuiDockNodeState_HostWindowHiddenBecauseWindowsAreResizing,
1792 ImGuiDockNodeState_HostWindowVisible,
1793};
1794
1795// sizeof() 156~192
1796struct 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.
1863enum 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
1874struct ImGuiWindowDockStyle
1875{
1876 ImU32 Colors[ImGuiWindowDockStyleCol_COUNT];
1877};
1878
1879struct 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.
1896struct 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)
1942struct 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
1961struct 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.
1981enum 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
1997struct ImGuiLocEntry
1998{
1999 ImGuiLocKey Key;
2000 const char* Text;
2001};
2002
2003
2004//-----------------------------------------------------------------------------
2005// [SECTION] Metrics, Debug Tools
2006//-----------------------------------------------------------------------------
2007
2008enum 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
2028struct ImGuiDebugAllocEntry
2029{
2030 int FrameCount;
2031 ImS16 AllocCount;
2032 ImS16 FreeCount;
2033};
2034
2035struct 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
2045struct 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
2063struct 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
2075struct 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
2091typedef void (*ImGuiContextHookCallback)(ImGuiContext* ctx, ImGuiContextHook* hook);
2092enum ImGuiContextHookType { ImGuiContextHookType_NewFramePre, ImGuiContextHookType_NewFramePost, ImGuiContextHookType_EndFramePre, ImGuiContextHookType_EndFramePost, ImGuiContextHookType_RenderPre, ImGuiContextHookType_RenderPost, ImGuiContextHookType_Shutdown, ImGuiContextHookType_PendingRemoval_ };
2093
2094struct 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
2109struct 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)
2669struct 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
2719struct 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
2847public:
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_
2870enum 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_
2878enum 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)
2887struct 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)
2907struct 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.
2954typedef ImS16 ImGuiTableColumnIdx;
2955typedef 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".
2961struct 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
3020struct 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
3028struct 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()
3042struct 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.
3165struct 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
3187struct 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.)
3211struct 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
3229namespace 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