1// dear imgui, v1.84 WIP
2// (internal structures/api)
3
4// You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
5// Set:
6// #define IMGUI_DEFINE_MATH_OPERATORS
7// To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
8
9/*
10
11Index of this file:
12
13// [SECTION] Header mess
14// [SECTION] Forward declarations
15// [SECTION] Context pointer
16// [SECTION] STB libraries includes
17// [SECTION] Macros
18// [SECTION] Generic helpers
19// [SECTION] ImDrawList support
20// [SECTION] Widgets support: flags, enums, data structures
21// [SECTION] Columns support
22// [SECTION] Multi-select support
23// [SECTION] Docking support
24// [SECTION] Viewport support
25// [SECTION] Settings support
26// [SECTION] Metrics, Debug
27// [SECTION] Generic context hooks
28// [SECTION] ImGuiContext (main imgui context)
29// [SECTION] ImGuiWindowTempData, ImGuiWindow
30// [SECTION] Tab bar, Tab item support
31// [SECTION] Table support
32// [SECTION] ImGui internal API
33// [SECTION] ImFontAtlas internal API
34// [SECTION] Test Engine specific hooks (imgui_test_engine)
35
36*/
37
38#pragma once
39#ifndef IMGUI_DISABLE
40
41//-----------------------------------------------------------------------------
42// [SECTION] Header mess
43//-----------------------------------------------------------------------------
44
45#ifndef IMGUI_VERSION
46#include "imgui.h"
47#endif
48
49#include <stdio.h> // FILE*, sscanf
50#include <stdlib.h> // NULL, malloc, free, qsort, atoi, atof
51#include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
52#include <limits.h> // INT_MIN, INT_MAX
53
54// Enable SSE intrinsics if available
55#if (defined __SSE__ || defined __x86_64__ || defined _M_X64) && !defined(IMGUI_DISABLE_SSE)
56#define IMGUI_ENABLE_SSE
57#include <immintrin.h>
58#endif
59
60// Visual Studio warnings
61#ifdef _MSC_VER
62#pragma warning (push)
63#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)
64#pragma warning (disable: 26812) // The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3). [MSVC Static Analyzer)
65#pragma warning (disable: 26495) // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6).
66#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later
67#pragma warning (disable: 5054) // operator '|': deprecated between enumerations of different types
68#endif
69#endif
70
71// Clang/GCC warnings with -Weverything
72#if defined(__clang__)
73#pragma clang diagnostic push
74#if __has_warning("-Wunknown-warning-option")
75#pragma clang diagnostic ignored "-Wunknown-warning-option" // warning: unknown warning group 'xxx'
76#endif
77#pragma clang diagnostic ignored "-Wunknown-pragmas" // warning: unknown warning group 'xxx'
78#pragma clang diagnostic ignored "-Wfloat-equal" // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok, for ImFloorSigned()
79#pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h
80#pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h
81#pragma clang diagnostic ignored "-Wold-style-cast"
82#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
83#pragma clang diagnostic ignored "-Wdouble-promotion"
84#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion" // warning: implicit conversion from 'xxx' to 'float' may lose precision
85#elif defined(__GNUC__)
86#pragma GCC diagnostic push
87#pragma GCC diagnostic ignored "-Wpragmas" // warning: unknown option after '#pragma GCC diagnostic' kind
88#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
89#endif
90
91// Legacy defines
92#ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS // Renamed in 1.74
93#error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS
94#endif
95#ifdef IMGUI_DISABLE_MATH_FUNCTIONS // Renamed in 1.74
96#error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
97#endif
98
99// Enable stb_truetype by default unless FreeType is enabled.
100// You can compile with both by defining both IMGUI_ENABLE_FREETYPE and IMGUI_ENABLE_STB_TRUETYPE together.
101#ifndef IMGUI_ENABLE_FREETYPE
102#define IMGUI_ENABLE_STB_TRUETYPE
103#endif
104
105//-----------------------------------------------------------------------------
106// [SECTION] Forward declarations
107//-----------------------------------------------------------------------------
108
109struct ImBitVector; // Store 1-bit per value
110struct ImRect; // An axis-aligned rectangle (2 points)
111struct ImDrawDataBuilder; // Helper to build a ImDrawData instance
112struct ImDrawListSharedData; // Data shared between all ImDrawList instances
113struct ImGuiColorMod; // Stacked color modifier, backup of modified data so we can restore it
114struct ImGuiContext; // Main Dear ImGui context
115struct ImGuiContextHook; // Hook for extensions like ImGuiTestEngine
116struct ImGuiDataTypeInfo; // Type information associated to a ImGuiDataType enum
117struct ImGuiGroupData; // Stacked storage data for BeginGroup()/EndGroup()
118struct ImGuiInputTextState; // Internal state of the currently focused/edited text input box
119struct ImGuiLastItemData; // Status storage for last submitted items
120struct ImGuiMenuColumns; // Simple column measurement, currently used for MenuItem() only
121struct ImGuiNavItemData; // Result of a gamepad/keyboard directional navigation move query result
122struct ImGuiMetricsConfig; // Storage for ShowMetricsWindow() and DebugNodeXXX() functions
123struct ImGuiNextWindowData; // Storage for SetNextWindow** functions
124struct ImGuiNextItemData; // Storage for SetNextItem** functions
125struct ImGuiOldColumnData; // Storage data for a single column for legacy Columns() api
126struct ImGuiOldColumns; // Storage data for a columns set for legacy Columns() api
127struct ImGuiPopupData; // Storage for current popup stack
128struct ImGuiSettingsHandler; // Storage for one type registered in the .ini file
129struct ImGuiStackSizes; // Storage of stack sizes for debugging/asserting
130struct ImGuiStyleMod; // Stacked style modifier, backup of modified data so we can restore it
131struct ImGuiTabBar; // Storage for a tab bar
132struct ImGuiTabItem; // Storage for a tab item (within a tab bar)
133struct ImGuiTable; // Storage for a table
134struct ImGuiTableColumn; // Storage for one column of a table
135struct ImGuiTableTempData; // Temporary storage for one table (one per table in the stack), shared between tables.
136struct ImGuiTableSettings; // Storage for a table .ini settings
137struct ImGuiTableColumnsSettings; // Storage for a column .ini settings
138struct ImGuiWindow; // Storage for one window
139struct 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)
140struct ImGuiWindowSettings; // Storage for a window .ini settings (we keep one of those even if the actual window wasn't instanced during this session)
141
142// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.
143typedef int ImGuiLayoutType; // -> enum ImGuiLayoutType_ // Enum: Horizontal or vertical
144typedef int ImGuiItemFlags; // -> enum ImGuiItemFlags_ // Flags: for PushItemFlag()
145typedef int ImGuiItemAddFlags; // -> enum ImGuiItemAddFlags_ // Flags: for ItemAdd()
146typedef int ImGuiItemStatusFlags; // -> enum ImGuiItemStatusFlags_ // Flags: for DC.LastItemStatusFlags
147typedef int ImGuiOldColumnFlags; // -> enum ImGuiOldColumnFlags_ // Flags: for BeginColumns()
148typedef int ImGuiNavHighlightFlags; // -> enum ImGuiNavHighlightFlags_ // Flags: for RenderNavHighlight()
149typedef int ImGuiNavDirSourceFlags; // -> enum ImGuiNavDirSourceFlags_ // Flags: for GetNavInputAmount2d()
150typedef int ImGuiNavMoveFlags; // -> enum ImGuiNavMoveFlags_ // Flags: for navigation requests
151typedef int ImGuiNextItemDataFlags; // -> enum ImGuiNextItemDataFlags_ // Flags: for SetNextItemXXX() functions
152typedef int ImGuiNextWindowDataFlags; // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions
153typedef int ImGuiSeparatorFlags; // -> enum ImGuiSeparatorFlags_ // Flags: for SeparatorEx()
154typedef int ImGuiTextFlags; // -> enum ImGuiTextFlags_ // Flags: for TextEx()
155typedef int ImGuiTooltipFlags; // -> enum ImGuiTooltipFlags_ // Flags: for BeginTooltipEx()
156
157typedef void (*ImGuiErrorLogCallback)(void* user_data, const char* fmt, ...);
158
159//-----------------------------------------------------------------------------
160// [SECTION] Context pointer
161// See implementation of this variable in imgui.cpp for comments and details.
162//-----------------------------------------------------------------------------
163
164#ifndef GImGui
165extern IMGUI_API ImGuiContext* GImGui; // Current implicit context pointer
166#endif
167
168//-------------------------------------------------------------------------
169// [SECTION] STB libraries includes
170//-------------------------------------------------------------------------
171
172namespace ImStb
173{
174
175#undef STB_TEXTEDIT_STRING
176#undef STB_TEXTEDIT_CHARTYPE
177#define STB_TEXTEDIT_STRING ImGuiInputTextState
178#define STB_TEXTEDIT_CHARTYPE ImWchar
179#define STB_TEXTEDIT_GETWIDTH_NEWLINE (-1.0f)
180#define STB_TEXTEDIT_UNDOSTATECOUNT 99
181#define STB_TEXTEDIT_UNDOCHARCOUNT 999
182#include "imstb_textedit.h"
183
184} // namespace ImStb
185
186//-----------------------------------------------------------------------------
187// [SECTION] Macros
188//-----------------------------------------------------------------------------
189
190// Debug Logging
191#ifndef IMGUI_DEBUG_LOG
192#define IMGUI_DEBUG_LOG(_FMT,...) printf("[%05d] " _FMT, GImGui->FrameCount, __VA_ARGS__)
193#endif
194
195// Debug Logging for selected systems. Remove the '((void)0) //' to enable.
196//#define IMGUI_DEBUG_LOG_POPUP IMGUI_DEBUG_LOG // Enable log
197//#define IMGUI_DEBUG_LOG_NAV IMGUI_DEBUG_LOG // Enable log
198#define IMGUI_DEBUG_LOG_POPUP(...) ((void)0) // Disable log
199#define IMGUI_DEBUG_LOG_NAV(...) ((void)0) // Disable log
200
201// Static Asserts
202#if (__cplusplus >= 201100) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201100)
203#define IM_STATIC_ASSERT(_COND) static_assert(_COND, "")
204#else
205#define IM_STATIC_ASSERT(_COND) typedef char static_assertion_##__line__[(_COND)?1:-1]
206#endif
207
208// "Paranoid" Debug Asserts are meant to only be enabled during specific debugging/work, otherwise would slow down the code too much.
209// 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.
210//#define IMGUI_DEBUG_PARANOID
211#ifdef IMGUI_DEBUG_PARANOID
212#define IM_ASSERT_PARANOID(_EXPR) IM_ASSERT(_EXPR)
213#else
214#define IM_ASSERT_PARANOID(_EXPR)
215#endif
216
217// Error handling
218// 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.
219#ifndef IM_ASSERT_USER_ERROR
220#define IM_ASSERT_USER_ERROR(_EXP,_MSG) IM_ASSERT((_EXP) && _MSG) // Recoverable User Error
221#endif
222
223// Misc Macros
224#define IM_PI 3.14159265358979323846f
225#ifdef _WIN32
226#define IM_NEWLINE "\r\n" // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!)
227#else
228#define IM_NEWLINE "\n"
229#endif
230#define IM_TABSIZE (4)
231#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
232#define IM_F32_TO_INT8_UNBOUND(_VAL) ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f))) // Unsaturated, for display purpose
233#define IM_F32_TO_INT8_SAT(_VAL) ((int)(ImSaturate(_VAL) * 255.0f + 0.5f)) // Saturated, always output 0..255
234#define IM_FLOOR(_VAL) ((float)(int)(_VAL)) // ImFloor() is not inlined in MSVC debug builds
235#define IM_ROUND(_VAL) ((float)(int)((_VAL) + 0.5f)) //
236
237// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
238#ifdef _MSC_VER
239#define IMGUI_CDECL __cdecl
240#else
241#define IMGUI_CDECL
242#endif
243
244// Warnings
245#if defined(_MSC_VER) && !defined(__clang__)
246#define IM_MSVC_WARNING_SUPPRESS(XXXX) __pragma(warning(suppress: XXXX))
247#else
248#define IM_MSVC_WARNING_SUPPRESS(XXXX)
249#endif
250
251// Debug Tools
252// Use 'Metrics->Tools->Item Picker' to break into the call-stack of a specific item.
253#ifndef IM_DEBUG_BREAK
254#if defined(__clang__)
255#define IM_DEBUG_BREAK() __builtin_debugtrap()
256#elif defined (_MSC_VER)
257#define IM_DEBUG_BREAK() __debugbreak()
258#else
259#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!
260#endif
261#endif // #ifndef IM_DEBUG_BREAK
262
263//-----------------------------------------------------------------------------
264// [SECTION] Generic helpers
265// Note that the ImXXX helpers functions are lower-level than ImGui functions.
266// ImGui functions or the ImGui context are never called/used from other ImXXX functions.
267//-----------------------------------------------------------------------------
268// - Helpers: Hashing
269// - Helpers: Sorting
270// - Helpers: Bit manipulation
271// - Helpers: String, Formatting
272// - Helpers: UTF-8 <> wchar conversions
273// - Helpers: ImVec2/ImVec4 operators
274// - Helpers: Maths
275// - Helpers: Geometry
276// - Helper: ImVec1
277// - Helper: ImVec2ih
278// - Helper: ImRect
279// - Helper: ImBitArray
280// - Helper: ImBitVector
281// - Helper: ImSpan<>, ImSpanAllocator<>
282// - Helper: ImPool<>
283// - Helper: ImChunkStream<>
284//-----------------------------------------------------------------------------
285
286// Helpers: Hashing
287IMGUI_API ImGuiID ImHashData(const void* data, size_t data_size, ImU32 seed = 0);
288IMGUI_API ImGuiID ImHashStr(const char* data, size_t data_size = 0, ImU32 seed = 0);
289#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
290static inline ImGuiID ImHash(const void* data, int size, ImU32 seed = 0) { return size ? ImHashData(data, (size_t)size, seed) : ImHashStr((const char*)data, 0, seed); } // [moved to ImHashStr/ImHashData in 1.68]
291#endif
292
293// Helpers: Sorting
294#define ImQsort qsort
295
296// Helpers: Color Blending
297IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);
298
299// Helpers: Bit manipulation
300static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
301static inline bool ImIsPowerOfTwo(ImU64 v) { return v != 0 && (v & (v - 1)) == 0; }
302static inline int ImUpperPowerOfTwo(int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
303
304// Helpers: String, Formatting
305IMGUI_API int ImStricmp(const char* str1, const char* str2);
306IMGUI_API int ImStrnicmp(const char* str1, const char* str2, size_t count);
307IMGUI_API void ImStrncpy(char* dst, const char* src, size_t count);
308IMGUI_API char* ImStrdup(const char* str);
309IMGUI_API char* ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str);
310IMGUI_API const char* ImStrchrRange(const char* str_begin, const char* str_end, char c);
311IMGUI_API int ImStrlenW(const ImWchar* str);
312IMGUI_API const char* ImStreolRange(const char* str, const char* str_end); // End end-of-line
313IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line
314IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
315IMGUI_API void ImStrTrimBlanks(char* str);
316IMGUI_API const char* ImStrSkipBlank(const char* str);
317IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
318IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
319IMGUI_API const char* ImParseFormatFindStart(const char* format);
320IMGUI_API const char* ImParseFormatFindEnd(const char* format);
321IMGUI_API const char* ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);
322IMGUI_API int ImParseFormatPrecision(const char* format, int default_value);
323static inline bool ImCharIsBlankA(char c) { return c == ' ' || c == '\t'; }
324static inline bool ImCharIsBlankW(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
325
326// Helpers: UTF-8 <> wchar conversions
327IMGUI_API const char* ImTextCharToUtf8(char out_buf[5], unsigned int c); // return out_buf
328IMGUI_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
329IMGUI_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
330IMGUI_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
331IMGUI_API int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count)
332IMGUI_API int ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end); // return number of bytes to express one char in UTF-8
333IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string in UTF-8
334
335// Helpers: ImVec2/ImVec4 operators
336// We are keeping those disabled by default so they don't leak in user space, to allow user enabling implicit cast operators between ImVec2 and their own types (using IM_VEC2_CLASS_EXTRA etc.)
337// We unfortunately don't have a unary- operator for ImVec2 because this would needs to be defined inside the class itself.
338#ifdef IMGUI_DEFINE_MATH_OPERATORS
339IM_MSVC_RUNTIME_CHECKS_OFF
340static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x * rhs, lhs.y * rhs); }
341static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x / rhs, lhs.y / rhs); }
342static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x + rhs.x, lhs.y + rhs.y); }
343static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x - rhs.x, lhs.y - rhs.y); }
344static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
345static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x / rhs.x, lhs.y / rhs.y); }
346static inline ImVec2& operator*=(ImVec2& lhs, const float rhs) { lhs.x *= rhs; lhs.y *= rhs; return lhs; }
347static inline ImVec2& operator/=(ImVec2& lhs, const float rhs) { lhs.x /= rhs; lhs.y /= rhs; return lhs; }
348static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs) { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; }
349static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs) { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }
350static inline ImVec2& operator*=(ImVec2& lhs, const ImVec2& rhs) { lhs.x *= rhs.x; lhs.y *= rhs.y; return lhs; }
351static inline ImVec2& operator/=(ImVec2& lhs, const ImVec2& rhs) { lhs.x /= rhs.x; lhs.y /= rhs.y; return lhs; }
352static inline ImVec4 operator+(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); }
353static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); }
354static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); }
355IM_MSVC_RUNTIME_CHECKS_RESTORE
356#endif
357
358// Helpers: File System
359#ifdef IMGUI_DISABLE_FILE_FUNCTIONS
360#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
361typedef void* ImFileHandle;
362static inline ImFileHandle ImFileOpen(const char*, const char*) { return NULL; }
363static inline bool ImFileClose(ImFileHandle) { return false; }
364static inline ImU64 ImFileGetSize(ImFileHandle) { return (ImU64)-1; }
365static inline ImU64 ImFileRead(void*, ImU64, ImU64, ImFileHandle) { return 0; }
366static inline ImU64 ImFileWrite(const void*, ImU64, ImU64, ImFileHandle) { return 0; }
367#endif
368#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
369typedef FILE* ImFileHandle;
370IMGUI_API ImFileHandle ImFileOpen(const char* filename, const char* mode);
371IMGUI_API bool ImFileClose(ImFileHandle file);
372IMGUI_API ImU64 ImFileGetSize(ImFileHandle file);
373IMGUI_API ImU64 ImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file);
374IMGUI_API ImU64 ImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file);
375#else
376#define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions
377#endif
378IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size = NULL, int padding_bytes = 0);
379
380// Helpers: Maths
381IM_MSVC_RUNTIME_CHECKS_OFF
382// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)
383#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
384#define ImFabs(X) fabsf(X)
385#define ImSqrt(X) sqrtf(X)
386#define ImFmod(X, Y) fmodf((X), (Y))
387#define ImCos(X) cosf(X)
388#define ImSin(X) sinf(X)
389#define ImAcos(X) acosf(X)
390#define ImAtan2(Y, X) atan2f((Y), (X))
391#define ImAtof(STR) atof(STR)
392//#define ImFloorStd(X) floorf(X) // We use our own, see ImFloor() and ImFloorSigned()
393#define ImCeil(X) ceilf(X)
394static inline float ImPow(float x, float y) { return powf(x, y); } // DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision
395static inline double ImPow(double x, double y) { return pow(x, y); }
396static inline float ImLog(float x) { return logf(x); } // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision
397static inline double ImLog(double x) { return log(x); }
398static inline int ImAbs(int x) { return x < 0 ? -x : x; }
399static inline float ImAbs(float x) { return fabsf(x); }
400static inline double ImAbs(double x) { return fabs(x); }
401static 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
402static inline double ImSign(double x) { return (x < 0.0) ? -1.0 : ((x > 0.0) ? 1.0 : 0.0); }
403#ifdef IMGUI_ENABLE_SSE
404static inline float ImRsqrt(float x) { return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }
405#else
406static inline float ImRsqrt(float x) { return 1.0f / sqrtf(x); }
407#endif
408static inline double ImRsqrt(double x) { return 1.0 / sqrt(x); }
409#endif
410// - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support variety of types: signed/unsigned int/long long float/double
411// (Exceptionally using templates here but we could also redefine them for those types)
412template<typename T> static inline T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; }
413template<typename T> static inline T ImMax(T lhs, T rhs) { return lhs >= rhs ? lhs : rhs; }
414template<typename T> static inline T ImClamp(T v, T mn, T mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
415template<typename T> static inline T ImLerp(T a, T b, float t) { return (T)(a + (b - a) * t); }
416template<typename T> static inline void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
417template<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; }
418template<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; }
419// - Misc maths helpers
420static 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); }
421static 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); }
422static 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); }
423static 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); }
424static 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); }
425static 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); }
426static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
427static inline float ImLengthSqr(const ImVec2& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y); }
428static inline float ImLengthSqr(const ImVec4& lhs) { return (lhs.x * lhs.x) + (lhs.y * lhs.y) + (lhs.z * lhs.z) + (lhs.w * lhs.w); }
429static 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(d); return fail_value; }
430static inline float ImFloor(float f) { return (float)(int)(f); }
431static inline float ImFloorSigned(float f) { return (float)((f >= 0 || (int)f == f) ? (int)f : (int)f - 1); } // Decent replacement for floorf()
432static inline ImVec2 ImFloor(const ImVec2& v) { return ImVec2((float)(int)(v.x), (float)(int)(v.y)); }
433static inline int ImModPositive(int a, int b) { return (a + b) % b; }
434static inline float ImDot(const ImVec2& a, const ImVec2& b) { return a.x * b.x + a.y * b.y; }
435static 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); }
436static inline float ImLinearSweep(float current, float target, float speed) { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }
437static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
438IM_MSVC_RUNTIME_CHECKS_RESTORE
439
440// Helpers: Geometry
441IMGUI_API ImVec2 ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t);
442IMGUI_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
443IMGUI_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
444IMGUI_API ImVec2 ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t);
445IMGUI_API ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
446IMGUI_API bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
447IMGUI_API ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
448IMGUI_API void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
449inline 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; }
450IMGUI_API ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy);
451
452// Helper: ImVec1 (1D vector)
453// (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)
454IM_MSVC_RUNTIME_CHECKS_OFF
455struct ImVec1
456{
457 float x;
458 ImVec1() { x = 0.0f; }
459 ImVec1(float _x) { x = _x; }
460};
461
462// Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage)
463struct ImVec2ih
464{
465 short x, y;
466 ImVec2ih() { x = y = 0; }
467 ImVec2ih(short _x, short _y) { x = _x; y = _y; }
468 explicit ImVec2ih(const ImVec2& rhs) { x = (short)rhs.x; y = (short)rhs.y; }
469};
470
471// Helper: ImRect (2D axis aligned bounding-box)
472// NB: we can't rely on ImVec2 math operators being available here!
473struct IMGUI_API ImRect
474{
475 ImVec2 Min; // Upper-left
476 ImVec2 Max; // Lower-right
477
478 ImRect() : Min(0.0f, 0.0f), Max(0.0f, 0.0f) {}
479 ImRect(const ImVec2& min, const ImVec2& max) : Min(min), Max(max) {}
480 ImRect(const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {}
481 ImRect(float x1, float y1, float x2, float y2) : Min(x1, y1), Max(x2, y2) {}
482
483 ImVec2 GetCenter() const { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
484 ImVec2 GetSize() const { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
485 float GetWidth() const { return Max.x - Min.x; }
486 float GetHeight() const { return Max.y - Min.y; }
487 float GetArea() const { return (Max.x - Min.x) * (Max.y - Min.y); }
488 ImVec2 GetTL() const { return Min; } // Top-left
489 ImVec2 GetTR() const { return ImVec2(Max.x, Min.y); } // Top-right
490 ImVec2 GetBL() const { return ImVec2(Min.x, Max.y); } // Bottom-left
491 ImVec2 GetBR() const { return Max; } // Bottom-right
492 bool Contains(const ImVec2& p) const { return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; }
493 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; }
494 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; }
495 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; }
496 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; }
497 void Expand(const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; }
498 void Expand(const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
499 void Translate(const ImVec2& d) { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }
500 void TranslateX(float dx) { Min.x += dx; Max.x += dx; }
501 void TranslateY(float dy) { Min.y += dy; Max.y += dy; }
502 void ClipWith(const ImRect& r) { Min = ImMax(Min, r.Min); Max = ImMin(Max, r.Max); } // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
503 void ClipWithFull(const ImRect& r) { Min = ImClamp(Min, r.Min, r.Max); Max = ImClamp(Max, r.Min, r.Max); } // Full version, ensure both points are fully clipped.
504 void Floor() { Min.x = IM_FLOOR(Min.x); Min.y = IM_FLOOR(Min.y); Max.x = IM_FLOOR(Max.x); Max.y = IM_FLOOR(Max.y); }
505 bool IsInverted() const { return Min.x > Max.x || Min.y > Max.y; }
506 ImVec4 ToVec4() const { return ImVec4(Min.x, Min.y, Max.x, Max.y); }
507};
508IM_MSVC_RUNTIME_CHECKS_RESTORE
509
510// Helper: ImBitArray
511inline bool ImBitArrayTestBit(const ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); return (arr[n >> 5] & mask) != 0; }
512inline void ImBitArrayClearBit(ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] &= ~mask; }
513inline void ImBitArraySetBit(ImU32* arr, int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] |= mask; }
514inline void ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)
515{
516 n2--;
517 while (n <= n2)
518 {
519 int a_mod = (n & 31);
520 int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
521 ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
522 arr[n >> 5] |= mask;
523 n = (n + 32) & ~31;
524 }
525}
526
527// Helper: ImBitArray class (wrapper over ImBitArray functions)
528// Store 1-bit per value.
529template<int BITCOUNT>
530struct IMGUI_API ImBitArray
531{
532 ImU32 Storage[(BITCOUNT + 31) >> 5];
533 ImBitArray() { ClearAllBits(); }
534 void ClearAllBits() { memset(Storage, 0, sizeof(Storage)); }
535 void SetAllBits() { memset(Storage, 255, sizeof(Storage)); }
536 bool TestBit(int n) const { IM_ASSERT(n < BITCOUNT); return ImBitArrayTestBit(Storage, n); }
537 void SetBit(int n) { IM_ASSERT(n < BITCOUNT); ImBitArraySetBit(Storage, n); }
538 void ClearBit(int n) { IM_ASSERT(n < BITCOUNT); ImBitArrayClearBit(Storage, n); }
539 void SetBitRange(int n, int n2) { ImBitArraySetBitRange(Storage, n, n2); } // Works on range [n..n2)
540};
541
542// Helper: ImBitVector
543// Store 1-bit per value.
544struct IMGUI_API ImBitVector
545{
546 ImVector<ImU32> Storage;
547 void Create(int sz) { Storage.resize((sz + 31) >> 5); memset(Storage.Data, 0, (size_t)Storage.Size * sizeof(Storage.Data[0])); }
548 void Clear() { Storage.clear(); }
549 bool TestBit(int n) const { IM_ASSERT(n < (Storage.Size << 5)); return ImBitArrayTestBit(Storage.Data, n); }
550 void SetBit(int n) { IM_ASSERT(n < (Storage.Size << 5)); ImBitArraySetBit(Storage.Data, n); }
551 void ClearBit(int n) { IM_ASSERT(n < (Storage.Size << 5)); ImBitArrayClearBit(Storage.Data, n); }
552};
553
554// Helper: ImSpan<>
555// Pointing to a span of data we don't own.
556template<typename T>
557struct ImSpan
558{
559 T* Data;
560 T* DataEnd;
561
562 // Constructors, destructor
563 inline ImSpan() { Data = DataEnd = NULL; }
564 inline ImSpan(T* data, int size) { Data = data; DataEnd = data + size; }
565 inline ImSpan(T* data, T* data_end) { Data = data; DataEnd = data_end; }
566
567 inline void set(T* data, int size) { Data = data; DataEnd = data + size; }
568 inline void set(T* data, T* data_end) { Data = data; DataEnd = data_end; }
569 inline int size() const { return (int)(ptrdiff_t)(DataEnd - Data); }
570 inline int size_in_bytes() const { return (int)(ptrdiff_t)(DataEnd - Data) * (int)sizeof(T); }
571 inline T& operator[](int i) { T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }
572 inline const T& operator[](int i) const { const T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }
573
574 inline T* begin() { return Data; }
575 inline const T* begin() const { return Data; }
576 inline T* end() { return DataEnd; }
577 inline const T* end() const { return DataEnd; }
578
579 // Utilities
580 inline int index_from_ptr(const T* it) const { IM_ASSERT(it >= Data && it < DataEnd); const ptrdiff_t off = it - Data; return (int)off; }
581};
582
583// Helper: ImSpanAllocator<>
584// Facilitate storing multiple chunks into a single large block (the "arena")
585// - Usage: call Reserve() N times, allocate GetArenaSizeInBytes() worth, pass it to SetArenaBasePtr(), call GetSpan() N times to retrieve the aligned ranges.
586template<int CHUNKS>
587struct ImSpanAllocator
588{
589 char* BasePtr;
590 int CurrOff;
591 int CurrIdx;
592 int Offsets[CHUNKS];
593 int Sizes[CHUNKS];
594
595 ImSpanAllocator() { memset(this, 0, sizeof(*this)); }
596 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; }
597 inline int GetArenaSizeInBytes() { return CurrOff; }
598 inline void SetArenaBasePtr(void* base_ptr) { BasePtr = (char*)base_ptr; }
599 inline void* GetSpanPtrBegin(int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n]); }
600 inline void* GetSpanPtrEnd(int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n] + Sizes[n]); }
601 template<typename T>
602 inline void GetSpan(int n, ImSpan<T>* span) { span->set((T*)GetSpanPtrBegin(n), (T*)GetSpanPtrEnd(n)); }
603};
604
605// Helper: ImPool<>
606// Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer,
607// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object.
608typedef int ImPoolIdx;
609template<typename T>
610struct IMGUI_API ImPool
611{
612 ImVector<T> Buf; // Contiguous data
613 ImGuiStorage Map; // ID->Index
614 ImPoolIdx FreeIdx; // Next free idx to use
615 ImPoolIdx AliveCount; // Number of active/alive items (for display purpose)
616
617 ImPool() { FreeIdx = AliveCount = 0; }
618 ~ImPool() { Clear(); }
619 T* GetByKey(ImGuiID key) { int idx = Map.GetInt(key, -1); return (idx != -1) ? &Buf[idx] : NULL; }
620 T* GetByIndex(ImPoolIdx n) { return &Buf[n]; }
621 ImPoolIdx GetIndex(const T* p) const { IM_ASSERT(p >= Buf.Data && p < Buf.Data + Buf.Size); return (ImPoolIdx)(p - Buf.Data); }
622 T* GetOrAddByKey(ImGuiID key) { int* p_idx = Map.GetIntRef(key, -1); if (*p_idx != -1) return &Buf[*p_idx]; *p_idx = FreeIdx; return Add(); }
623 bool Contains(const T* p) const { return (p >= Buf.Data && p < Buf.Data + Buf.Size); }
624 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; }
625 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]; }
626 void Remove(ImGuiID key, const T* p) { Remove(key, GetIndex(p)); }
627 void Remove(ImGuiID key, ImPoolIdx idx) { Buf[idx].~T(); *(int*)&Buf[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); AliveCount--; }
628 void Reserve(int capacity) { Buf.reserve(capacity); Map.Data.reserve(capacity); }
629
630 // To iterate a ImPool: for (int n = 0; n < pool.GetMapSize(); n++) if (T* t = pool.TryGetMapData(n)) { ... }
631 // Can be avoided if you know .Remove() has never been called on the pool, or AliveCount == GetMapSize()
632 int GetAliveCount() const { return AliveCount; } // Number of active/alive items in the pool (for display purpose)
633 int GetBufSize() const { return Buf.Size; }
634 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
635 T* TryGetMapData(ImPoolIdx n) { int idx = Map.Data[n].val_i; if (idx == -1) return NULL; return GetByIndex(idx); }
636#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
637 int GetSize() { return GetMapSize(); } // For ImPlot: should use GetMapSize() from (IMGUI_VERSION_NUM >= 18304)
638#endif
639};
640
641// Helper: ImChunkStream<>
642// Build and iterate a contiguous stream of variable-sized structures.
643// This is used by Settings to store persistent data while reducing allocation count.
644// We store the chunk size first, and align the final size on 4 bytes boundaries.
645// The tedious/zealous amount of casting is to avoid -Wcast-align warnings.
646template<typename T>
647struct IMGUI_API ImChunkStream
648{
649 ImVector<char> Buf;
650
651 void clear() { Buf.clear(); }
652 bool empty() const { return Buf.Size == 0; }
653 int size() const { return Buf.Size; }
654 T* alloc_chunk(size_t sz) { size_t HDR_SZ = 4; sz = IM_MEMALIGN(HDR_SZ + sz, 4u); int off = Buf.Size; Buf.resize(off + (int)sz); ((int*)(void*)(Buf.Data + off))[0] = (int)sz; return (T*)(void*)(Buf.Data + off + (int)HDR_SZ); }
655 T* begin() { size_t HDR_SZ = 4; if (!Buf.Data) return NULL; return (T*)(void*)(Buf.Data + HDR_SZ); }
656 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; }
657 int chunk_size(const T* p) { return ((const int*)p)[-1]; }
658 T* end() { return (T*)(void*)(Buf.Data + Buf.Size); }
659 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; }
660 T* ptr_from_offset(int off) { IM_ASSERT(off >= 4 && off < Buf.Size); return (T*)(void*)(Buf.Data + off); }
661 void swap(ImChunkStream<T>& rhs) { rhs.Buf.swap(Buf); }
662
663};
664
665//-----------------------------------------------------------------------------
666// [SECTION] ImDrawList support
667//-----------------------------------------------------------------------------
668
669// ImDrawList: Helper function to calculate a circle's segment count given its radius and a "maximum error" value.
670// Estimation of number of circle segment based on error is derived using method described in https://stackoverflow.com/a/2244088/15194693
671// Number of segments (N) is calculated using equation:
672// N = ceil ( pi / acos(1 - error / r) ) where r > 0, error <= r
673// Our equation is significantly simpler that one in the post thanks for choosing segment that is
674// perpendicular to X axis. Follow steps in the article from this starting condition and you will
675// will get this result.
676//
677// Rendering circles with an odd number of segments, while mathematically correct will produce
678// asymmetrical results on the raster grid. Therefore we're rounding N to next even number (7->8, 8->8, 9->10 etc.)
679//
680#define IM_ROUNDUP_TO_EVEN(_V) ((((_V) + 1) / 2) * 2)
681#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN 4
682#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX 512
683#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)
684
685// Raw equation from IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC rewritten for 'r' and 'error'.
686#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR) ((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))))
687#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD) ((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD))
688
689// ImDrawList: Lookup table size for adaptive arc drawing, cover full circle.
690#ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE
691#define IM_DRAWLIST_ARCFAST_TABLE_SIZE 48 // Number of samples in lookup table.
692#endif
693#define IM_DRAWLIST_ARCFAST_SAMPLE_MAX IM_DRAWLIST_ARCFAST_TABLE_SIZE // Sample index _PathArcToFastEx() for 360 angle.
694
695// Data shared between all ImDrawList instances
696// 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.
697struct IMGUI_API ImDrawListSharedData
698{
699 ImVec2 TexUvWhitePixel; // UV of white pixel in the atlas
700 ImFont* Font; // Current/default font (optional, for simplified AddText overload)
701 float FontSize; // Current/default font size (optional, for simplified AddText overload)
702 float CurveTessellationTol; // Tessellation tolerance when using PathBezierCurveTo()
703 float CircleSegmentMaxError; // Number of circle segments to use per pixel of radius for AddCircle() etc
704 ImVec4 ClipRectFullscreen; // Value for PushClipRectFullscreen()
705 ImDrawListFlags InitialFlags; // Initial flags at the beginning of the frame (it is possible to alter flags on a per-drawlist basis afterwards)
706
707 // [Internal] Lookup tables
708 ImVec2 ArcFastVtx[IM_DRAWLIST_ARCFAST_TABLE_SIZE]; // Sample points on the quarter of the circle.
709 float ArcFastRadiusCutoff; // Cutoff radius after which arc drawing will fallback to slower PathArcTo()
710 ImU8 CircleSegmentCounts[64]; // Precomputed segment count for given radius before we calculate it dynamically (to avoid calculation overhead)
711 const ImVec4* TexUvLines; // UV of anti-aliased lines in the atlas
712
713 ImDrawListSharedData();
714 void SetCircleTessellationMaxError(float max_error);
715};
716
717struct ImDrawDataBuilder
718{
719 ImVector<ImDrawList*> Layers[2]; // Global layers for: regular, tooltip
720
721 void Clear() { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].resize(0); }
722 void ClearFreeMemory() { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].clear(); }
723 int GetDrawListCount() const { int count = 0; for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) count += Layers[n].Size; return count; }
724 IMGUI_API void FlattenIntoSingleLayer();
725};
726
727//-----------------------------------------------------------------------------
728// [SECTION] Widgets support: flags, enums, data structures
729//-----------------------------------------------------------------------------
730
731// Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
732// This is going to be exposed in imgui.h when stabilized enough.
733enum ImGuiItemFlags_
734{
735 ImGuiItemFlags_None = 0,
736 ImGuiItemFlags_NoTabStop = 1 << 0, // false // Disable keyboard tabbing (FIXME: should merge with _NoNav)
737 ImGuiItemFlags_ButtonRepeat = 1 << 1, // false // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
738 ImGuiItemFlags_Disabled = 1 << 2, // false // Disable interactions but doesn't affect visuals. See PushDisabled()/PushDisabled(). See github.com/ocornut/imgui/issues/211
739 ImGuiItemFlags_NoNav = 1 << 3, // false // Disable keyboard/gamepad directional navigation (FIXME: should merge with _NoTabStop)
740 ImGuiItemFlags_NoNavDefaultFocus = 1 << 4, // false // Disable item being a candidate for default focus (e.g. used by title bar items)
741 ImGuiItemFlags_SelectableDontClosePopup = 1 << 5, // false // Disable MenuItem/Selectable() automatically closing their popup window
742 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)
743 ImGuiItemFlags_ReadOnly = 1 << 7 // false // [ALPHA] Allow hovering interactions but underlying value is not changed.
744};
745
746// Flags for ItemAdd()
747// FIXME-NAV: _Focusable is _ALMOST_ what you would expect to be called '_TabStop' but because SetKeyboardFocusHere() works on items with no TabStop we distinguish Focusable from TabStop.
748enum ImGuiItemAddFlags_
749{
750 ImGuiItemAddFlags_None = 0,
751 ImGuiItemAddFlags_Focusable = 1 << 0 // FIXME-NAV: In current/legacy scheme, Focusable+TabStop support are opt-in by widgets. We will transition it toward being opt-out, so this flag is expected to eventually disappear.
752};
753
754// Storage for LastItem data
755enum ImGuiItemStatusFlags_
756{
757 ImGuiItemStatusFlags_None = 0,
758 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)
759 ImGuiItemStatusFlags_HasDisplayRect = 1 << 1, // window->DC.LastItemDisplayRect is valid
760 ImGuiItemStatusFlags_Edited = 1 << 2, // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
761 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.
762 ImGuiItemStatusFlags_ToggledOpen = 1 << 4, // Set when TreeNode() reports toggling their open state.
763 ImGuiItemStatusFlags_HasDeactivated = 1 << 5, // Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag.
764 ImGuiItemStatusFlags_Deactivated = 1 << 6, // Only valid if ImGuiItemStatusFlags_HasDeactivated is set.
765 ImGuiItemStatusFlags_HoveredWindow = 1 << 7, // Override the HoveredWindow test to allow cross-window hover testing.
766 ImGuiItemStatusFlags_FocusedByCode = 1 << 8, // Set when the Focusable item just got focused from code.
767 ImGuiItemStatusFlags_FocusedByTabbing = 1 << 9, // Set when the Focusable item just got focused by Tabbing.
768 ImGuiItemStatusFlags_Focused = ImGuiItemStatusFlags_FocusedByCode | ImGuiItemStatusFlags_FocusedByTabbing
769
770#ifdef IMGUI_ENABLE_TEST_ENGINE
771 , // [imgui_tests only]
772 ImGuiItemStatusFlags_Openable = 1 << 20, //
773 ImGuiItemStatusFlags_Opened = 1 << 21, //
774 ImGuiItemStatusFlags_Checkable = 1 << 22, //
775 ImGuiItemStatusFlags_Checked = 1 << 23 //
776#endif
777};
778
779// Extend ImGuiInputTextFlags_
780enum ImGuiInputTextFlagsPrivate_
781{
782 // [Internal]
783 ImGuiInputTextFlags_Multiline = 1 << 26, // For internal use by InputTextMultiline()
784 ImGuiInputTextFlags_NoMarkEdited = 1 << 27, // For internal use by functions using InputText() before reformatting data
785 ImGuiInputTextFlags_MergedItem = 1 << 28 // For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match.
786};
787
788// Extend ImGuiButtonFlags_
789enum ImGuiButtonFlagsPrivate_
790{
791 ImGuiButtonFlags_PressedOnClick = 1 << 4, // return true on click (mouse down event)
792 ImGuiButtonFlags_PressedOnClickRelease = 1 << 5, // [Default] return true on click + release on same item <-- this is what the majority of Button are using
793 ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 1 << 6, // return true on click + release even if the release event is not done while hovering the item
794 ImGuiButtonFlags_PressedOnRelease = 1 << 7, // return true on release (default requires click+release)
795 ImGuiButtonFlags_PressedOnDoubleClick = 1 << 8, // return true on double-click (default requires click+release)
796 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)
797 ImGuiButtonFlags_Repeat = 1 << 10, // hold to repeat
798 ImGuiButtonFlags_FlattenChildren = 1 << 11, // allow interactions even if a child window is overlapping
799 ImGuiButtonFlags_AllowItemOverlap = 1 << 12, // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
800 ImGuiButtonFlags_DontClosePopups = 1 << 13, // disable automatically closing parent popup on press // [UNUSED]
801 //ImGuiButtonFlags_Disabled = 1 << 14, // disable interactions -> use PushDisabled() or ImGuiItemFlags_Disabled
802 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
803 ImGuiButtonFlags_NoKeyModifiers = 1 << 16, // disable mouse interaction if a key modifier is held
804 ImGuiButtonFlags_NoHoldingActiveId = 1 << 17, // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
805 ImGuiButtonFlags_NoNavFocus = 1 << 18, // don't override navigation focus when activated
806 ImGuiButtonFlags_NoHoveredOnFocus = 1 << 19, // don't report as hovered when nav focus is on this item
807 ImGuiButtonFlags_PressedOnMask_ = ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold,
808 ImGuiButtonFlags_PressedOnDefault_ = ImGuiButtonFlags_PressedOnClickRelease
809};
810
811// Extend ImGuiComboFlags_
812enum ImGuiComboFlagsPrivate_
813{
814 ImGuiComboFlags_CustomPreview = 1 << 20 // enable BeginComboPreview()
815};
816
817// Extend ImGuiSliderFlags_
818enum ImGuiSliderFlagsPrivate_
819{
820 ImGuiSliderFlags_Vertical = 1 << 20, // Should this slider be orientated vertically?
821 ImGuiSliderFlags_ReadOnly = 1 << 21
822};
823
824// Extend ImGuiSelectableFlags_
825enum ImGuiSelectableFlagsPrivate_
826{
827 // NB: need to be in sync with last value of ImGuiSelectableFlags_
828 ImGuiSelectableFlags_NoHoldingActiveID = 1 << 20,
829 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.
830 ImGuiSelectableFlags_SelectOnClick = 1 << 22, // Override button behavior to react on Click (default is Click+Release)
831 ImGuiSelectableFlags_SelectOnRelease = 1 << 23, // Override button behavior to react on Release (default is Click+Release)
832 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)
833 ImGuiSelectableFlags_DrawHoveredWhenHeld = 1 << 25, // Always show active when held, even is not hovered. This concept could probably be renamed/formalized somehow.
834 ImGuiSelectableFlags_SetNavIdOnHover = 1 << 26, // Set Nav/Focus ID on mouse hover (used by MenuItem)
835 ImGuiSelectableFlags_NoPadWithHalfSpacing = 1 << 27 // Disable padding each side with ItemSpacing * 0.5f
836};
837
838// Extend ImGuiTreeNodeFlags_
839enum ImGuiTreeNodeFlagsPrivate_
840{
841 ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1 << 20
842};
843
844enum ImGuiSeparatorFlags_
845{
846 ImGuiSeparatorFlags_None = 0,
847 ImGuiSeparatorFlags_Horizontal = 1 << 0, // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
848 ImGuiSeparatorFlags_Vertical = 1 << 1,
849 ImGuiSeparatorFlags_SpanAllColumns = 1 << 2
850};
851
852enum ImGuiTextFlags_
853{
854 ImGuiTextFlags_None = 0,
855 ImGuiTextFlags_NoWidthForLargeClippedText = 1 << 0
856};
857
858enum ImGuiTooltipFlags_
859{
860 ImGuiTooltipFlags_None = 0,
861 ImGuiTooltipFlags_OverridePreviousTooltip = 1 << 0 // Override will clear/ignore previously submitted tooltip (defaults to append)
862};
863
864// FIXME: this is in development, not exposed/functional as a generic feature yet.
865// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2
866enum ImGuiLayoutType_
867{
868 ImGuiLayoutType_Horizontal = 0,
869 ImGuiLayoutType_Vertical = 1
870};
871
872enum ImGuiLogType
873{
874 ImGuiLogType_None = 0,
875 ImGuiLogType_TTY,
876 ImGuiLogType_File,
877 ImGuiLogType_Buffer,
878 ImGuiLogType_Clipboard
879};
880
881// X/Y enums are fixed to 0/1 so they may be used to index ImVec2
882enum ImGuiAxis
883{
884 ImGuiAxis_None = -1,
885 ImGuiAxis_X = 0,
886 ImGuiAxis_Y = 1
887};
888
889enum ImGuiPlotType
890{
891 ImGuiPlotType_Lines,
892 ImGuiPlotType_Histogram
893};
894
895enum ImGuiInputSource
896{
897 ImGuiInputSource_None = 0,
898 ImGuiInputSource_Mouse,
899 ImGuiInputSource_Keyboard,
900 ImGuiInputSource_Gamepad,
901 ImGuiInputSource_Nav, // Stored in g.ActiveIdSource only
902 ImGuiInputSource_Clipboard, // Currently only used by InputText()
903 ImGuiInputSource_COUNT
904};
905
906// FIXME-NAV: Clarify/expose various repeat delay/rate
907enum ImGuiInputReadMode
908{
909 ImGuiInputReadMode_Down,
910 ImGuiInputReadMode_Pressed,
911 ImGuiInputReadMode_Released,
912 ImGuiInputReadMode_Repeat,
913 ImGuiInputReadMode_RepeatSlow,
914 ImGuiInputReadMode_RepeatFast
915};
916
917enum ImGuiNavHighlightFlags_
918{
919 ImGuiNavHighlightFlags_None = 0,
920 ImGuiNavHighlightFlags_TypeDefault = 1 << 0,
921 ImGuiNavHighlightFlags_TypeThin = 1 << 1,
922 ImGuiNavHighlightFlags_AlwaysDraw = 1 << 2, // Draw rectangular highlight if (g.NavId == id) _even_ when using the mouse.
923 ImGuiNavHighlightFlags_NoRounding = 1 << 3
924};
925
926enum ImGuiNavDirSourceFlags_
927{
928 ImGuiNavDirSourceFlags_None = 0,
929 ImGuiNavDirSourceFlags_Keyboard = 1 << 0,
930 ImGuiNavDirSourceFlags_PadDPad = 1 << 1,
931 ImGuiNavDirSourceFlags_PadLStick = 1 << 2
932};
933
934enum ImGuiNavMoveFlags_
935{
936 ImGuiNavMoveFlags_None = 0,
937 ImGuiNavMoveFlags_LoopX = 1 << 0, // On failed request, restart from opposite side
938 ImGuiNavMoveFlags_LoopY = 1 << 1,
939 ImGuiNavMoveFlags_WrapX = 1 << 2, // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
940 ImGuiNavMoveFlags_WrapY = 1 << 3, // This is not super useful for provided for completeness
941 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)
942 ImGuiNavMoveFlags_AlsoScoreVisibleSet = 1 << 5, // Store alternate result in NavMoveResultLocalVisibleSet that only comprise elements that are already fully visible.
943 ImGuiNavMoveFlags_ScrollToEdge = 1 << 6
944};
945
946enum ImGuiNavForward
947{
948 ImGuiNavForward_None,
949 ImGuiNavForward_ForwardQueued,
950 ImGuiNavForward_ForwardActive
951};
952
953enum ImGuiNavLayer
954{
955 ImGuiNavLayer_Main = 0, // Main scrolling layer
956 ImGuiNavLayer_Menu = 1, // Menu layer (access with Alt/ImGuiNavInput_Menu)
957 ImGuiNavLayer_COUNT
958};
959
960enum ImGuiPopupPositionPolicy
961{
962 ImGuiPopupPositionPolicy_Default,
963 ImGuiPopupPositionPolicy_ComboBox,
964 ImGuiPopupPositionPolicy_Tooltip
965};
966
967struct ImGuiDataTypeTempStorage
968{
969 ImU8 Data[8]; // Can fit any data up to ImGuiDataType_COUNT
970};
971
972// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo().
973struct ImGuiDataTypeInfo
974{
975 size_t Size; // Size in bytes
976 const char* Name; // Short descriptive name for the type, for debugging
977 const char* PrintFmt; // Default printf format for the type
978 const char* ScanFmt; // Default scanf format for the type
979};
980
981// Extend ImGuiDataType_
982enum ImGuiDataTypePrivate_
983{
984 ImGuiDataType_String = ImGuiDataType_COUNT + 1,
985 ImGuiDataType_Pointer,
986 ImGuiDataType_ID
987};
988
989// Stacked color modifier, backup of modified data so we can restore it
990struct ImGuiColorMod
991{
992 ImGuiCol Col;
993 ImVec4 BackupValue;
994};
995
996// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
997struct ImGuiStyleMod
998{
999 ImGuiStyleVar VarIdx;
1000 union { int BackupInt[2]; float BackupFloat[2]; };
1001 ImGuiStyleMod(ImGuiStyleVar idx, int v) { VarIdx = idx; BackupInt[0] = v; }
1002 ImGuiStyleMod(ImGuiStyleVar idx, float v) { VarIdx = idx; BackupFloat[0] = v; }
1003 ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }
1004};
1005
1006// Storage data for BeginComboPreview()/EndComboPreview()
1007struct IMGUI_API ImGuiComboPreviewData
1008{
1009 ImRect PreviewRect;
1010 ImVec2 BackupCursorPos;
1011 ImVec2 BackupCursorMaxPos;
1012 ImVec2 BackupCursorPosPrevLine;
1013 float BackupPrevLineTextBaseOffset;
1014 ImGuiLayoutType BackupLayout;
1015
1016 ImGuiComboPreviewData() { memset(this, 0, sizeof(*this)); }
1017};
1018
1019// Stacked storage data for BeginGroup()/EndGroup()
1020struct IMGUI_API ImGuiGroupData
1021{
1022 ImGuiID WindowID;
1023 ImVec2 BackupCursorPos;
1024 ImVec2 BackupCursorMaxPos;
1025 ImVec1 BackupIndent;
1026 ImVec1 BackupGroupOffset;
1027 ImVec2 BackupCurrLineSize;
1028 float BackupCurrLineTextBaseOffset;
1029 ImGuiID BackupActiveIdIsAlive;
1030 bool BackupActiveIdPreviousFrameIsAlive;
1031 bool BackupHoveredIdIsAlive;
1032 bool EmitItem;
1033};
1034
1035// Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
1036struct IMGUI_API ImGuiMenuColumns
1037{
1038 ImU32 TotalWidth;
1039 ImU32 NextTotalWidth;
1040 ImU16 Spacing;
1041 ImU16 OffsetIcon; // Always zero for now
1042 ImU16 OffsetLabel; // Offsets are locked in Update()
1043 ImU16 OffsetShortcut;
1044 ImU16 OffsetMark;
1045 ImU16 Widths[4]; // Width of: Icon, Label, Shortcut, Mark (accumulators for current frame)
1046
1047 ImGuiMenuColumns() { memset(this, 0, sizeof(*this)); }
1048 void Update(float spacing, bool window_reappearing);
1049 float DeclColumns(float w_icon, float w_label, float w_shortcut, float w_mark);
1050 void CalcNextTotalWidth(bool update_offsets);
1051};
1052
1053// Internal state of the currently focused/edited text input box
1054// For a given item ID, access with ImGui::GetInputTextState()
1055struct IMGUI_API ImGuiInputTextState
1056{
1057 ImGuiID ID; // widget id owning the text state
1058 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.
1059 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.
1060 ImVector<char> TextA; // temporary UTF8 buffer for callbacks and other operations. this is not updated in every code-path! size=capacity.
1061 ImVector<char> InitialTextA; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
1062 bool TextAIsValid; // temporary UTF8 buffer is not initially valid before we make the widget active (until then we pull the data from user argument)
1063 int BufCapacityA; // end-user buffer capacity
1064 float ScrollX; // horizontal scrolling/offset
1065 ImStb::STB_TexteditState Stb; // state for stb_textedit.h
1066 float CursorAnim; // timer for cursor blink, reset on every user action so the cursor reappears immediately
1067 bool CursorFollow; // set when we want scrolling to follow the current cursor position (not always!)
1068 bool SelectedAllMouseLock; // after a double-click to select all, we ignore further mouse drags to update selection
1069 bool Edited; // edited this frame
1070 ImGuiInputTextFlags Flags; // copy of InputText() flags
1071 ImGuiInputTextCallback UserCallback; // "
1072 void* UserCallbackData; // "
1073
1074 ImGuiInputTextState() { memset(this, 0, sizeof(*this)); }
1075 void ClearText() { CurLenW = CurLenA = 0; TextW[0] = 0; TextA[0] = 0; CursorClamp(); }
1076 void ClearFreeMemory() { TextW.clear(); TextA.clear(); InitialTextA.clear(); }
1077 int GetUndoAvailCount() const { return Stb.undostate.undo_point; }
1078 int GetRedoAvailCount() const { return STB_TEXTEDIT_UNDOSTATECOUNT - Stb.undostate.redo_point; }
1079 void OnKeyPressed(int key); // Cannot be inline because we call in code in stb_textedit.h implementation
1080
1081 // Cursor & Selection
1082 void CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking
1083 void CursorClamp() { Stb.cursor = ImMin(Stb.cursor, CurLenW); Stb.select_start = ImMin(Stb.select_start, CurLenW); Stb.select_end = ImMin(Stb.select_end, CurLenW); }
1084 bool HasSelection() const { return Stb.select_start != Stb.select_end; }
1085 void ClearSelection() { Stb.select_start = Stb.select_end = Stb.cursor; }
1086 int GetCursorPos() const { return Stb.cursor; }
1087 int GetSelectionStart() const { return Stb.select_start; }
1088 int GetSelectionEnd() const { return Stb.select_end; }
1089 void SelectAll() { Stb.select_start = 0; Stb.cursor = Stb.select_end = CurLenW; Stb.has_preferred_x = 0; }
1090};
1091
1092// Storage for current popup stack
1093struct ImGuiPopupData
1094{
1095 ImGuiID PopupId; // Set on OpenPopup()
1096 ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
1097 ImGuiWindow* SourceWindow; // Set on OpenPopup() copy of NavWindow at the time of opening the popup
1098 int OpenFrameCount; // Set on OpenPopup()
1099 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)
1100 ImVec2 OpenPopupPos; // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
1101 ImVec2 OpenMousePos; // Set on OpenPopup(), copy of mouse position at the time of opening popup
1102
1103 ImGuiPopupData() { memset(this, 0, sizeof(*this)); OpenFrameCount = -1; }
1104};
1105
1106struct ImGuiNavItemData
1107{
1108 ImGuiWindow* Window; // Init,Move // Best candidate window (result->ItemWindow->RootWindowForNav == request->Window)
1109 ImGuiID ID; // Init,Move // Best candidate item ID
1110 ImGuiID FocusScopeId; // Init,Move // Best candidate focus scope ID
1111 ImRect RectRel; // Init,Move // Best candidate bounding box in window relative space
1112 float DistBox; // Move // Best candidate box distance to current NavId
1113 float DistCenter; // Move // Best candidate center distance to current NavId
1114 float DistAxial; // Move // Best candidate axial distance to current NavId
1115
1116 ImGuiNavItemData() { Clear(); }
1117 void Clear() { Window = NULL; ID = FocusScopeId = 0; RectRel = ImRect(); DistBox = DistCenter = DistAxial = FLT_MAX; }
1118};
1119
1120enum ImGuiNextWindowDataFlags_
1121{
1122 ImGuiNextWindowDataFlags_None = 0,
1123 ImGuiNextWindowDataFlags_HasPos = 1 << 0,
1124 ImGuiNextWindowDataFlags_HasSize = 1 << 1,
1125 ImGuiNextWindowDataFlags_HasContentSize = 1 << 2,
1126 ImGuiNextWindowDataFlags_HasCollapsed = 1 << 3,
1127 ImGuiNextWindowDataFlags_HasSizeConstraint = 1 << 4,
1128 ImGuiNextWindowDataFlags_HasFocus = 1 << 5,
1129 ImGuiNextWindowDataFlags_HasBgAlpha = 1 << 6,
1130 ImGuiNextWindowDataFlags_HasScroll = 1 << 7
1131};
1132
1133// Storage for SetNexWindow** functions
1134struct ImGuiNextWindowData
1135{
1136 ImGuiNextWindowDataFlags Flags;
1137 ImGuiCond PosCond;
1138 ImGuiCond SizeCond;
1139 ImGuiCond CollapsedCond;
1140 ImVec2 PosVal;
1141 ImVec2 PosPivotVal;
1142 ImVec2 SizeVal;
1143 ImVec2 ContentSizeVal;
1144 ImVec2 ScrollVal;
1145 bool CollapsedVal;
1146 ImRect SizeConstraintRect;
1147 ImGuiSizeCallback SizeCallback;
1148 void* SizeCallbackUserData;
1149 float BgAlphaVal; // Override background alpha
1150 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?)
1151
1152 ImGuiNextWindowData() { memset(this, 0, sizeof(*this)); }
1153 inline void ClearFlags() { Flags = ImGuiNextWindowDataFlags_None; }
1154};
1155
1156enum ImGuiNextItemDataFlags_
1157{
1158 ImGuiNextItemDataFlags_None = 0,
1159 ImGuiNextItemDataFlags_HasWidth = 1 << 0,
1160 ImGuiNextItemDataFlags_HasOpen = 1 << 1
1161};
1162
1163struct ImGuiNextItemData
1164{
1165 ImGuiNextItemDataFlags Flags;
1166 float Width; // Set by SetNextItemWidth()
1167 ImGuiID FocusScopeId; // Set by SetNextItemMultiSelectData() (!= 0 signify value has been set, so it's an alternate version of HasSelectionData, we don't use Flags for this because they are cleared too early. This is mostly used for debugging)
1168 ImGuiCond OpenCond;
1169 bool OpenVal; // Set by SetNextItemOpen()
1170
1171 ImGuiNextItemData() { memset(this, 0, sizeof(*this)); }
1172 inline void ClearFlags() { Flags = ImGuiNextItemDataFlags_None; } // Also cleared manually by ItemAdd()!
1173};
1174
1175// Status storage for the last submitted item
1176struct ImGuiLastItemData
1177{
1178 ImGuiID ID;
1179 ImGuiItemFlags InFlags; // See ImGuiItemFlags_
1180 ImGuiItemStatusFlags StatusFlags; // See ImGuiItemStatusFlags_
1181 ImRect Rect;
1182 ImRect DisplayRect;
1183
1184 ImGuiLastItemData() { memset(this, 0, sizeof(*this)); }
1185};
1186
1187// Data saved for each window pushed into the stack
1188struct ImGuiWindowStackData
1189{
1190 ImGuiWindow* Window;
1191 ImGuiLastItemData ParentLastItemDataBackup;
1192};
1193
1194struct ImGuiShrinkWidthItem
1195{
1196 int Index;
1197 float Width;
1198};
1199
1200struct ImGuiPtrOrIndex
1201{
1202 void* Ptr; // Either field can be set, not both. e.g. Dock node tab bars are loose while BeginTabBar() ones are in a pool.
1203 int Index; // Usually index in a main pool.
1204
1205 ImGuiPtrOrIndex(void* ptr) { Ptr = ptr; Index = -1; }
1206 ImGuiPtrOrIndex(int index) { Ptr = NULL; Index = index; }
1207};
1208
1209//-----------------------------------------------------------------------------
1210// [SECTION] Columns support
1211//-----------------------------------------------------------------------------
1212
1213// Flags for internal's BeginColumns(). Prefix using BeginTable() nowadays!
1214enum ImGuiOldColumnFlags_
1215{
1216 ImGuiOldColumnFlags_None = 0,
1217 ImGuiOldColumnFlags_NoBorder = 1 << 0, // Disable column dividers
1218 ImGuiOldColumnFlags_NoResize = 1 << 1, // Disable resizing columns when clicking on the dividers
1219 ImGuiOldColumnFlags_NoPreserveWidths = 1 << 2, // Disable column width preservation when adjusting columns
1220 ImGuiOldColumnFlags_NoForceWithinWindow = 1 << 3, // Disable forcing columns to fit within window
1221 ImGuiOldColumnFlags_GrowParentContentsSize = 1 << 4 // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
1222
1223 // Obsolete names (will be removed)
1224#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
1225 , ImGuiColumnsFlags_None = ImGuiOldColumnFlags_None,
1226 ImGuiColumnsFlags_NoBorder = ImGuiOldColumnFlags_NoBorder,
1227 ImGuiColumnsFlags_NoResize = ImGuiOldColumnFlags_NoResize,
1228 ImGuiColumnsFlags_NoPreserveWidths = ImGuiOldColumnFlags_NoPreserveWidths,
1229 ImGuiColumnsFlags_NoForceWithinWindow = ImGuiOldColumnFlags_NoForceWithinWindow,
1230 ImGuiColumnsFlags_GrowParentContentsSize = ImGuiOldColumnFlags_GrowParentContentsSize
1231#endif
1232};
1233
1234struct ImGuiOldColumnData
1235{
1236 float OffsetNorm; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
1237 float OffsetNormBeforeResize;
1238 ImGuiOldColumnFlags Flags; // Not exposed
1239 ImRect ClipRect;
1240
1241 ImGuiOldColumnData() { memset(this, 0, sizeof(*this)); }
1242};
1243
1244struct ImGuiOldColumns
1245{
1246 ImGuiID ID;
1247 ImGuiOldColumnFlags Flags;
1248 bool IsFirstFrame;
1249 bool IsBeingResized;
1250 int Current;
1251 int Count;
1252 float OffMinX, OffMaxX; // Offsets from HostWorkRect.Min.x
1253 float LineMinY, LineMaxY;
1254 float HostCursorPosY; // Backup of CursorPos at the time of BeginColumns()
1255 float HostCursorMaxPosX; // Backup of CursorMaxPos at the time of BeginColumns()
1256 ImRect HostInitialClipRect; // Backup of ClipRect at the time of BeginColumns()
1257 ImRect HostBackupClipRect; // Backup of ClipRect during PushColumnsBackground()/PopColumnsBackground()
1258 ImRect HostBackupParentWorkRect;//Backup of WorkRect at the time of BeginColumns()
1259 ImVector<ImGuiOldColumnData> Columns;
1260 ImDrawListSplitter Splitter;
1261
1262 ImGuiOldColumns() { memset(this, 0, sizeof(*this)); }
1263};
1264
1265//-----------------------------------------------------------------------------
1266// [SECTION] Multi-select support
1267//-----------------------------------------------------------------------------
1268
1269#ifdef IMGUI_HAS_MULTI_SELECT
1270// <this is filled in 'range_select' branch>
1271#endif // #ifdef IMGUI_HAS_MULTI_SELECT
1272
1273//-----------------------------------------------------------------------------
1274// [SECTION] Docking support
1275//-----------------------------------------------------------------------------
1276
1277#ifdef IMGUI_HAS_DOCK
1278// <this is filled in 'docking' branch>
1279#endif // #ifdef IMGUI_HAS_DOCK
1280
1281//-----------------------------------------------------------------------------
1282// [SECTION] Viewport support
1283//-----------------------------------------------------------------------------
1284
1285// ImGuiViewport Private/Internals fields (cardinal sin: we are using inheritance!)
1286// Every instance of ImGuiViewport is in fact a ImGuiViewportP.
1287struct ImGuiViewportP : public ImGuiViewport
1288{
1289 int DrawListsLastFrame[2]; // Last frame number the background (0) and foreground (1) draw lists were used
1290 ImDrawList* DrawLists[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.
1291 ImDrawData DrawDataP;
1292 ImDrawDataBuilder DrawDataBuilder;
1293
1294 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!)
1295 ImVec2 WorkOffsetMax; // Work Area: Offset from Pos+Size to bottom-right corner of Work Area. Generally (0,0) or (0,-status_bar_height).
1296 ImVec2 BuildWorkOffsetMin; // Work Area: Offset being built during current frame. Generally >= 0.0f.
1297 ImVec2 BuildWorkOffsetMax; // Work Area: Offset being built during current frame. Generally <= 0.0f.
1298
1299 ImGuiViewportP() { DrawListsLastFrame[0] = DrawListsLastFrame[1] = -1; DrawLists[0] = DrawLists[1] = NULL; }
1300 ~ImGuiViewportP() { if (DrawLists[0]) IM_DELETE(DrawLists[0]); if (DrawLists[1]) IM_DELETE(DrawLists[1]); }
1301
1302 // 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)
1303 ImVec2 CalcWorkRectPos(const ImVec2& off_min) const { return ImVec2(Pos.x + off_min.x, Pos.y + off_min.y); }
1304 ImVec2 CalcWorkRectSize(const ImVec2& off_min, const ImVec2& off_max) const { return ImVec2(ImMax(0.0f, Size.x - off_min.x + off_max.x), ImMax(0.0f, Size.y - off_min.y + off_max.y)); }
1305 void UpdateWorkRect() { WorkPos = CalcWorkRectPos(WorkOffsetMin); WorkSize = CalcWorkRectSize(WorkOffsetMin, WorkOffsetMax); } // Update public fields
1306
1307 // Helpers to retrieve ImRect (we don't need to store BuildWorkRect as every access tend to change it, hence the code asymmetry)
1308 ImRect GetMainRect() const { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
1309 ImRect GetWorkRect() const { return ImRect(WorkPos.x, WorkPos.y, WorkPos.x + WorkSize.x, WorkPos.y + WorkSize.y); }
1310 ImRect GetBuildWorkRect() const { ImVec2 pos = CalcWorkRectPos(BuildWorkOffsetMin); ImVec2 size = CalcWorkRectSize(BuildWorkOffsetMin, BuildWorkOffsetMax); return ImRect(pos.x, pos.y, pos.x + size.x, pos.y + size.y); }
1311};
1312
1313//-----------------------------------------------------------------------------
1314// [SECTION] Settings support
1315//-----------------------------------------------------------------------------
1316
1317// Windows data saved in imgui.ini file
1318// Because we never destroy or rename ImGuiWindowSettings, we can store the names in a separate buffer easily.
1319// (this is designed to be stored in a ImChunkStream buffer, with the variable-length Name following our structure)
1320struct ImGuiWindowSettings
1321{
1322 ImGuiID ID;
1323 ImVec2ih Pos;
1324 ImVec2ih Size;
1325 bool Collapsed;
1326 bool WantApply; // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)
1327
1328 ImGuiWindowSettings() { memset(this, 0, sizeof(*this)); }
1329 char* GetName() { return (char*)(this + 1); }
1330};
1331
1332struct ImGuiSettingsHandler
1333{
1334 const char* TypeName; // Short description stored in .ini file. Disallowed characters: '[' ']'
1335 ImGuiID TypeHash; // == ImHashStr(TypeName)
1336 void (*ClearAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Clear all settings data
1337 void (*ReadInitFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Read: Called before reading (in registration order)
1338 void* (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name); // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
1339 void (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry
1340 void (*ApplyAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler); // Read: Called after reading (in registration order)
1341 void (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf); // Write: Output every entries into 'out_buf'
1342 void* UserData;
1343
1344 ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
1345};
1346
1347//-----------------------------------------------------------------------------
1348// [SECTION] Metrics, Debug
1349//-----------------------------------------------------------------------------
1350
1351struct ImGuiMetricsConfig
1352{
1353 bool ShowWindowsRects;
1354 bool ShowWindowsBeginOrder;
1355 bool ShowTablesRects;
1356 bool ShowDrawCmdMesh;
1357 bool ShowDrawCmdBoundingBoxes;
1358 int ShowWindowsRectsType;
1359 int ShowTablesRectsType;
1360
1361 ImGuiMetricsConfig()
1362 {
1363 ShowWindowsRects = false;
1364 ShowWindowsBeginOrder = false;
1365 ShowTablesRects = false;
1366 ShowDrawCmdMesh = true;
1367 ShowDrawCmdBoundingBoxes = true;
1368 ShowWindowsRectsType = -1;
1369 ShowTablesRectsType = -1;
1370 }
1371};
1372
1373struct IMGUI_API ImGuiStackSizes
1374{
1375 short SizeOfIDStack;
1376 short SizeOfColorStack;
1377 short SizeOfStyleVarStack;
1378 short SizeOfFontStack;
1379 short SizeOfFocusScopeStack;
1380 short SizeOfGroupStack;
1381 short SizeOfBeginPopupStack;
1382
1383 ImGuiStackSizes() { memset(this, 0, sizeof(*this)); }
1384 void SetToCurrentState();
1385 void CompareWithCurrentState();
1386};
1387
1388//-----------------------------------------------------------------------------
1389// [SECTION] Generic context hooks
1390//-----------------------------------------------------------------------------
1391
1392typedef void (*ImGuiContextHookCallback)(ImGuiContext* ctx, ImGuiContextHook* hook);
1393enum ImGuiContextHookType { ImGuiContextHookType_NewFramePre, ImGuiContextHookType_NewFramePost, ImGuiContextHookType_EndFramePre, ImGuiContextHookType_EndFramePost, ImGuiContextHookType_RenderPre, ImGuiContextHookType_RenderPost, ImGuiContextHookType_Shutdown, ImGuiContextHookType_PendingRemoval_ };
1394
1395struct ImGuiContextHook
1396{
1397 ImGuiID HookId; // A unique ID assigned by AddContextHook()
1398 ImGuiContextHookType Type;
1399 ImGuiID Owner;
1400 ImGuiContextHookCallback Callback;
1401 void* UserData;
1402
1403 ImGuiContextHook() { memset(this, 0, sizeof(*this)); }
1404};
1405
1406//-----------------------------------------------------------------------------
1407// [SECTION] ImGuiContext (main imgui context)
1408//-----------------------------------------------------------------------------
1409
1410struct ImGuiContext
1411{
1412 bool Initialized;
1413 bool FontAtlasOwnedByContext; // IO.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
1414 ImGuiIO IO;
1415 ImGuiStyle Style;
1416 ImFont* Font; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
1417 float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
1418 float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
1419 ImDrawListSharedData DrawListSharedData;
1420 double Time;
1421 int FrameCount;
1422 int FrameCountEnded;
1423 int FrameCountRendered;
1424 bool WithinFrameScope; // Set by NewFrame(), cleared by EndFrame()
1425 bool WithinFrameScopeWithImplicitWindow; // Set by NewFrame(), cleared by EndFrame() when the implicit debug window has been pushed
1426 bool WithinEndChild; // Set within EndChild()
1427 bool GcCompactAll; // Request full GC
1428 bool TestEngineHookItems; // Will call test engine hooks: ImGuiTestEngineHook_ItemAdd(), ImGuiTestEngineHook_ItemInfo(), ImGuiTestEngineHook_Log()
1429 ImGuiID TestEngineHookIdInfo; // Will call test engine hooks: ImGuiTestEngineHook_IdInfo() from GetID()
1430 void* TestEngine; // Test engine user data
1431
1432 // Windows state
1433 ImVector<ImGuiWindow*> Windows; // Windows, sorted in display order, back to front
1434 ImVector<ImGuiWindow*> WindowsFocusOrder; // Root windows, sorted in focus order, back to front.
1435 ImVector<ImGuiWindow*> WindowsTempSortBuffer; // Temporary buffer used in EndFrame() to reorder windows so parents are kept before their child
1436 ImVector<ImGuiWindowStackData> CurrentWindowStack;
1437 ImGuiStorage WindowsById; // Map window's ImGuiID to ImGuiWindow*
1438 int WindowsActiveCount; // Number of unique windows submitted by frame
1439 ImVec2 WindowsHoverPadding; // Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, WINDOWS_HOVER_PADDING)
1440 ImGuiWindow* CurrentWindow; // Window being drawn into
1441 ImGuiWindow* HoveredWindow; // Window the mouse is hovering. Will typically catch mouse inputs.
1442 ImGuiWindow* HoveredWindowUnderMovingWindow; // Hovered window ignoring MovingWindow. Only set if MovingWindow is set.
1443 ImGuiWindow* MovingWindow; // Track the window we clicked on (in order to preserve focus). The actual window that is moved is generally MovingWindow->RootWindow.
1444 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.
1445 ImVec2 WheelingWindowRefMousePos;
1446 float WheelingWindowTimer;
1447
1448 // Item/widgets state and tracking information
1449 ImGuiID HoveredId; // Hovered widget, filled during the frame
1450 ImGuiID HoveredIdPreviousFrame;
1451 bool HoveredIdAllowOverlap;
1452 bool HoveredIdUsingMouseWheel; // Hovered widget will use mouse wheel. Blocks scrolling the underlying window.
1453 bool HoveredIdPreviousFrameUsingMouseWheel;
1454 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.
1455 float HoveredIdTimer; // Measure contiguous hovering time
1456 float HoveredIdNotActiveTimer; // Measure contiguous hovering time where the item has not been active
1457 ImGuiID ActiveId; // Active widget
1458 ImGuiID ActiveIdIsAlive; // Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame)
1459 float ActiveIdTimer;
1460 bool ActiveIdIsJustActivated; // Set at the time of activation for one frame
1461 bool ActiveIdAllowOverlap; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
1462 bool ActiveIdNoClearOnFocusLoss; // Disable losing active id if the active id window gets unfocused.
1463 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.
1464 bool ActiveIdHasBeenEditedBefore; // Was the value associated to the widget Edited over the course of the Active state.
1465 bool ActiveIdHasBeenEditedThisFrame;
1466 bool ActiveIdUsingMouseWheel; // Active widget will want to read mouse wheel. Blocks scrolling the underlying window.
1467 ImU32 ActiveIdUsingNavDirMask; // Active widget will want to read those nav move requests (e.g. can activate a button and move away from it)
1468 ImU32 ActiveIdUsingNavInputMask; // Active widget will want to read those nav inputs.
1469 ImU64 ActiveIdUsingKeyInputMask; // Active widget will want to read those key inputs. When we grow the ImGuiKey enum we'll need to either to order the enum to make useful keys come first, either redesign this into e.g. a small array.
1470 ImVec2 ActiveIdClickOffset; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
1471 ImGuiWindow* ActiveIdWindow;
1472 ImGuiInputSource ActiveIdSource; // Activating with mouse or nav (gamepad/keyboard)
1473 int ActiveIdMouseButton;
1474 ImGuiID ActiveIdPreviousFrame;
1475 bool ActiveIdPreviousFrameIsAlive;
1476 bool ActiveIdPreviousFrameHasBeenEditedBefore;
1477 ImGuiWindow* ActiveIdPreviousFrameWindow;
1478 ImGuiID LastActiveId; // Store the last non-zero ActiveId, useful for animation.
1479 float LastActiveIdTimer; // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation.
1480
1481 // Next window/item data
1482 ImGuiItemFlags CurrentItemFlags; // == g.ItemFlagsStack.back()
1483 ImGuiNextItemData NextItemData; // Storage for SetNextItem** functions
1484 ImGuiLastItemData LastItemData; // Storage for last submitted item (setup by ItemAdd)
1485 ImGuiNextWindowData NextWindowData; // Storage for SetNextWindow** functions
1486
1487 // Shared stacks
1488 ImVector<ImGuiColorMod> ColorStack; // Stack for PushStyleColor()/PopStyleColor() - inherited by Begin()
1489 ImVector<ImGuiStyleMod> StyleVarStack; // Stack for PushStyleVar()/PopStyleVar() - inherited by Begin()
1490 ImVector<ImFont*> FontStack; // Stack for PushFont()/PopFont() - inherited by Begin()
1491 ImVector<ImGuiID> FocusScopeStack; // Stack for PushFocusScope()/PopFocusScope() - not inherited by Begin(), unless child window
1492 ImVector<ImGuiItemFlags>ItemFlagsStack; // Stack for PushItemFlag()/PopItemFlag() - inherited by Begin()
1493 ImVector<ImGuiGroupData>GroupStack; // Stack for BeginGroup()/EndGroup() - not inherited by Begin()
1494 ImVector<ImGuiPopupData>OpenPopupStack; // Which popups are open (persistent)
1495 ImVector<ImGuiPopupData>BeginPopupStack; // Which level of BeginPopup() we are in (reset every frame)
1496
1497 // Viewports
1498 ImVector<ImGuiViewportP*> Viewports; // Active viewports (Size==1 in 'master' branch). Each viewports hold their copy of ImDrawData.
1499
1500 // Gamepad/keyboard Navigation
1501 ImGuiWindow* NavWindow; // Focused window for navigation. Could be called 'FocusWindow'
1502 ImGuiID NavId; // Focused item for navigation
1503 ImGuiID NavFocusScopeId; // Identify a selection scope (selection code often wants to "clear other items" when landing on an item of the selection set)
1504 ImGuiID NavActivateId; // ~~ (g.ActiveId == 0) && IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0, also set when calling ActivateItem()
1505 ImGuiID NavActivateDownId; // ~~ IsNavInputDown(ImGuiNavInput_Activate) ? NavId : 0
1506 ImGuiID NavActivatePressedId; // ~~ IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0
1507 ImGuiID NavInputId; // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0
1508 ImGuiID NavJustTabbedId; // Just tabbed to this id.
1509 ImGuiID NavJustMovedToId; // Just navigated to this id (result of a successfully MoveRequest).
1510 ImGuiID NavJustMovedToFocusScopeId; // Just navigated to this focus scope id (result of a successfully MoveRequest).
1511 ImGuiKeyModFlags NavJustMovedToKeyMods;
1512 ImGuiID NavNextActivateId; // Set by ActivateItem(), queued until next frame.
1513 ImGuiInputSource NavInputSource; // Keyboard or Gamepad mode? THIS WILL ONLY BE None or NavGamepad or NavKeyboard.
1514 ImRect NavScoringRect; // Rectangle used for scoring, in screen space. Based of window->NavRectRel[], modified for directional navigation scoring.
1515 int NavScoringCount; // Metrics for debugging
1516 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.
1517 int NavIdTabCounter; // == NavWindow->DC.FocusIdxTabCounter at time of NavId processing
1518 bool NavIdIsAlive; // Nav widget has been seen this frame ~~ NavRectRel is valid
1519 bool NavMousePosDirty; // When set we will update mouse position if (io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos) if set (NB: this not enabled by default)
1520 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)
1521 bool NavDisableMouseHover; // When user starts using gamepad/keyboard, we hide mouse hovering highlight until mouse is touched again.
1522 bool NavAnyRequest; // ~~ NavMoveRequest || NavInitRequest
1523 bool NavInitRequest; // Init request for appearing window to select first item
1524 bool NavInitRequestFromMove;
1525 ImGuiID NavInitResultId; // Init request result (first item of the window, or one for which SetItemDefaultFocus() was called)
1526 ImRect NavInitResultRectRel; // Init request result rectangle (relative to parent window)
1527 bool NavMoveRequest; // Move request for this frame
1528 ImGuiNavMoveFlags NavMoveRequestFlags;
1529 ImGuiNavForward NavMoveRequestForward; // None / ForwardQueued / ForwardActive (this is used to navigate sibling parent menus from a child menu)
1530 ImGuiKeyModFlags NavMoveRequestKeyMods;
1531 ImGuiDir NavMoveDir, NavMoveDirLast; // Direction of the move request (left/right/up/down), direction of the previous move request
1532 ImGuiDir NavMoveClipDir; // FIXME-NAV: Describe the purpose of this better. Might want to rename?
1533 ImGuiNavItemData NavMoveResultLocal; // Best move request candidate within NavWindow
1534 ImGuiNavItemData NavMoveResultLocalVisibleSet; // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)
1535 ImGuiNavItemData NavMoveResultOther; // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)
1536 ImGuiWindow* NavWrapRequestWindow; // Window which requested trying nav wrap-around.
1537 ImGuiNavMoveFlags NavWrapRequestFlags; // Wrap-around operation flags.
1538
1539 // Navigation: Windowing (CTRL+TAB for list, or Menu button + keys or directional pads to move/resize)
1540 ImGuiWindow* NavWindowingTarget; // Target window when doing CTRL+Tab (or Pad Menu + FocusPrev/Next), this window is temporarily displayed top-most!
1541 ImGuiWindow* NavWindowingTargetAnim; // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f, so the fade-out can stay on it.
1542 ImGuiWindow* NavWindowingListWindow; // Internal window actually listing the CTRL+Tab contents
1543 float NavWindowingTimer;
1544 float NavWindowingHighlightAlpha;
1545 bool NavWindowingToggleLayer;
1546
1547 // Legacy Focus/Tabbing system (older than Nav, active even if Nav is disabled, misnamed. FIXME-NAV: This needs a redesign!)
1548 ImGuiWindow* TabFocusRequestCurrWindow; //
1549 ImGuiWindow* TabFocusRequestNextWindow; //
1550 int TabFocusRequestCurrCounterRegular; // Any item being requested for focus, stored as an index (we on layout to be stable between the frame pressing TAB and the next frame, semi-ouch)
1551 int TabFocusRequestCurrCounterTabStop; // Tab item being requested for focus, stored as an index
1552 int TabFocusRequestNextCounterRegular; // Stored for next frame
1553 int TabFocusRequestNextCounterTabStop; // "
1554 bool TabFocusPressed; // Set in NewFrame() when user pressed Tab
1555
1556 // Render
1557 float DimBgRatio; // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)
1558 ImGuiMouseCursor MouseCursor;
1559
1560 // Drag and Drop
1561 bool DragDropActive;
1562 bool DragDropWithinSource; // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag source.
1563 bool DragDropWithinTarget; // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag target.
1564 ImGuiDragDropFlags DragDropSourceFlags;
1565 int DragDropSourceFrameCount;
1566 int DragDropMouseButton;
1567 ImGuiPayload DragDropPayload;
1568 ImRect DragDropTargetRect; // Store rectangle of current target candidate (we favor small targets when overlapping)
1569 ImGuiID DragDropTargetId;
1570 ImGuiDragDropFlags DragDropAcceptFlags;
1571 float DragDropAcceptIdCurrRectSurface; // Target item surface (we resolve overlapping targets by prioritizing the smaller surface)
1572 ImGuiID DragDropAcceptIdCurr; // Target item id (set at the time of accepting the payload)
1573 ImGuiID DragDropAcceptIdPrev; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
1574 int DragDropAcceptFrameCount; // Last time a target expressed a desire to accept the source
1575 ImGuiID DragDropHoldJustPressedId; // Set when holding a payload just made ButtonBehavior() return a press.
1576 ImVector<unsigned char> DragDropPayloadBufHeap; // We don't expose the ImVector<> directly, ImGuiPayload only holds pointer+size
1577 unsigned char DragDropPayloadBufLocal[16]; // Local buffer for small payloads
1578
1579 // Table
1580 ImGuiTable* CurrentTable;
1581 int CurrentTableStackIdx;
1582 ImPool<ImGuiTable> Tables;
1583 ImVector<ImGuiTableTempData> TablesTempDataStack;
1584 ImVector<float> TablesLastTimeActive; // Last used timestamp of each tables (SOA, for efficient GC)
1585 ImVector<ImDrawChannel> DrawChannelsTempMergeBuffer;
1586
1587 // Tab bars
1588 ImGuiTabBar* CurrentTabBar;
1589 ImPool<ImGuiTabBar> TabBars;
1590 ImVector<ImGuiPtrOrIndex> CurrentTabBarStack;
1591 ImVector<ImGuiShrinkWidthItem> ShrinkWidthBuffer;
1592
1593 // Widget state
1594 ImVec2 LastValidMousePos;
1595 ImGuiInputTextState InputTextState;
1596 ImFont InputTextPasswordFont;
1597 ImGuiID TempInputId; // Temporary text input when CTRL+clicking on a slider, etc.
1598 ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets
1599 float ColorEditLastHue; // Backup of last Hue associated to LastColor[3], so we can restore Hue in lossy RGB<>HSV round trips
1600 float ColorEditLastSat; // Backup of last Saturation associated to LastColor[3], so we can restore Saturation in lossy RGB<>HSV round trips
1601 float ColorEditLastColor[3];
1602 ImVec4 ColorPickerRef; // Initial/reference color at the time of opening the color picker.
1603 ImGuiComboPreviewData ComboPreviewData;
1604 float SliderCurrentAccum; // Accumulated slider delta when using navigation controls.
1605 bool SliderCurrentAccumDirty; // Has the accumulated slider delta changed since last time we tried to apply it?
1606 bool DragCurrentAccumDirty;
1607 float DragCurrentAccum; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
1608 float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
1609 float ScrollbarClickDeltaToGrabCenter; // Distance between mouse and center of grab box, normalized in parent space. Use storage?
1610 int TooltipOverrideCount;
1611 float TooltipSlowDelay; // Time before slow tooltips appears (FIXME: This is temporary until we merge in tooltip timer+priority work)
1612 ImVector<char> ClipboardHandlerData; // If no custom clipboard handler is defined
1613 ImVector<ImGuiID> MenusIdSubmittedThisFrame; // A list of menu IDs that were rendered at least once
1614
1615 // Platform support
1616 ImVec2 PlatformImePos; // Cursor position request & last passed to the OS Input Method Editor
1617 ImVec2 PlatformImeLastPos;
1618 char PlatformLocaleDecimalPoint; // '.' or *localeconv()->decimal_point
1619
1620 // Settings
1621 bool SettingsLoaded;
1622 float SettingsDirtyTimer; // Save .ini Settings to memory when time reaches zero
1623 ImGuiTextBuffer SettingsIniData; // In memory .ini settings
1624 ImVector<ImGuiSettingsHandler> SettingsHandlers; // List of .ini settings handlers
1625 ImChunkStream<ImGuiWindowSettings> SettingsWindows; // ImGuiWindow .ini settings entries
1626 ImChunkStream<ImGuiTableSettings> SettingsTables; // ImGuiTable .ini settings entries
1627 ImVector<ImGuiContextHook> Hooks; // Hooks for extensions (e.g. test engine)
1628 ImGuiID HookIdNext; // Next available HookId
1629
1630 // Capture/Logging
1631 bool LogEnabled; // Currently capturing
1632 ImGuiLogType LogType; // Capture target
1633 ImFileHandle LogFile; // If != NULL log to stdout/ file
1634 ImGuiTextBuffer LogBuffer; // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
1635 const char* LogNextPrefix;
1636 const char* LogNextSuffix;
1637 float LogLinePosY;
1638 bool LogLineFirstItem;
1639 int LogDepthRef;
1640 int LogDepthToExpand;
1641 int LogDepthToExpandDefault; // Default/stored value for LogDepthMaxExpand if not specified in the LogXXX function call.
1642
1643 // Debug Tools
1644 bool DebugItemPickerActive; // Item picker is active (started with DebugStartItemPicker())
1645 ImGuiID DebugItemPickerBreakId; // Will call IM_DEBUG_BREAK() when encountering this id
1646 ImGuiMetricsConfig DebugMetricsConfig;
1647
1648 // Misc
1649 float FramerateSecPerFrame[120]; // Calculate estimate of framerate for user over the last 2 seconds.
1650 int FramerateSecPerFrameIdx;
1651 int FramerateSecPerFrameCount;
1652 float FramerateSecPerFrameAccum;
1653 int WantCaptureMouseNextFrame; // Explicit capture via CaptureKeyboardFromApp()/CaptureMouseFromApp() sets those flags
1654 int WantCaptureKeyboardNextFrame;
1655 int WantTextInputNextFrame;
1656 char TempBuffer[1024 * 3 + 1]; // Temporary text buffer
1657
1658 ImGuiContext(ImFontAtlas* shared_font_atlas)
1659 {
1660 Initialized = false;
1661 FontAtlasOwnedByContext = shared_font_atlas ? false : true;
1662 Font = NULL;
1663 FontSize = FontBaseSize = 0.0f;
1664 IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(ImFontAtlas)();
1665 Time = 0.0f;
1666 FrameCount = 0;
1667 FrameCountEnded = FrameCountRendered = -1;
1668 WithinFrameScope = WithinFrameScopeWithImplicitWindow = WithinEndChild = false;
1669 GcCompactAll = false;
1670 TestEngineHookItems = false;
1671 TestEngineHookIdInfo = 0;
1672 TestEngine = NULL;
1673
1674 WindowsActiveCount = 0;
1675 CurrentWindow = NULL;
1676 HoveredWindow = NULL;
1677 HoveredWindowUnderMovingWindow = NULL;
1678 MovingWindow = NULL;
1679 WheelingWindow = NULL;
1680 WheelingWindowTimer = 0.0f;
1681
1682 HoveredId = HoveredIdPreviousFrame = 0;
1683 HoveredIdAllowOverlap = false;
1684 HoveredIdUsingMouseWheel = HoveredIdPreviousFrameUsingMouseWheel = false;
1685 HoveredIdDisabled = false;
1686 HoveredIdTimer = HoveredIdNotActiveTimer = 0.0f;
1687 ActiveId = 0;
1688 ActiveIdIsAlive = 0;
1689 ActiveIdTimer = 0.0f;
1690 ActiveIdIsJustActivated = false;
1691 ActiveIdAllowOverlap = false;
1692 ActiveIdNoClearOnFocusLoss = false;
1693 ActiveIdHasBeenPressedBefore = false;
1694 ActiveIdHasBeenEditedBefore = false;
1695 ActiveIdHasBeenEditedThisFrame = false;
1696 ActiveIdUsingMouseWheel = false;
1697 ActiveIdUsingNavDirMask = 0x00;
1698 ActiveIdUsingNavInputMask = 0x00;
1699 ActiveIdUsingKeyInputMask = 0x00;
1700 ActiveIdClickOffset = ImVec2(-1, -1);
1701 ActiveIdWindow = NULL;
1702 ActiveIdSource = ImGuiInputSource_None;
1703 ActiveIdMouseButton = -1;
1704 ActiveIdPreviousFrame = 0;
1705 ActiveIdPreviousFrameIsAlive = false;
1706 ActiveIdPreviousFrameHasBeenEditedBefore = false;
1707 ActiveIdPreviousFrameWindow = NULL;
1708 LastActiveId = 0;
1709 LastActiveIdTimer = 0.0f;
1710
1711 CurrentItemFlags = ImGuiItemFlags_None;
1712
1713 NavWindow = NULL;
1714 NavId = NavFocusScopeId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavInputId = 0;
1715 NavJustTabbedId = NavJustMovedToId = NavJustMovedToFocusScopeId = NavNextActivateId = 0;
1716 NavJustMovedToKeyMods = ImGuiKeyModFlags_None;
1717 NavInputSource = ImGuiInputSource_None;
1718 NavScoringRect = ImRect();
1719 NavScoringCount = 0;
1720 NavLayer = ImGuiNavLayer_Main;
1721 NavIdTabCounter = INT_MAX;
1722 NavIdIsAlive = false;
1723 NavMousePosDirty = false;
1724 NavDisableHighlight = true;
1725 NavDisableMouseHover = false;
1726 NavAnyRequest = false;
1727 NavInitRequest = false;
1728 NavInitRequestFromMove = false;
1729 NavInitResultId = 0;
1730 NavMoveRequest = false;
1731 NavMoveRequestFlags = ImGuiNavMoveFlags_None;
1732 NavMoveRequestForward = ImGuiNavForward_None;
1733 NavMoveRequestKeyMods = ImGuiKeyModFlags_None;
1734 NavMoveDir = NavMoveDirLast = NavMoveClipDir = ImGuiDir_None;
1735 NavWrapRequestWindow = NULL;
1736 NavWrapRequestFlags = ImGuiNavMoveFlags_None;
1737
1738 NavWindowingTarget = NavWindowingTargetAnim = NavWindowingListWindow = NULL;
1739 NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
1740 NavWindowingToggleLayer = false;
1741
1742 TabFocusRequestCurrWindow = TabFocusRequestNextWindow = NULL;
1743 TabFocusRequestCurrCounterRegular = TabFocusRequestCurrCounterTabStop = INT_MAX;
1744 TabFocusRequestNextCounterRegular = TabFocusRequestNextCounterTabStop = INT_MAX;
1745 TabFocusPressed = false;
1746
1747 DimBgRatio = 0.0f;
1748 MouseCursor = ImGuiMouseCursor_Arrow;
1749
1750 DragDropActive = DragDropWithinSource = DragDropWithinTarget = false;
1751 DragDropSourceFlags = ImGuiDragDropFlags_None;
1752 DragDropSourceFrameCount = -1;
1753 DragDropMouseButton = -1;
1754 DragDropTargetId = 0;
1755 DragDropAcceptFlags = ImGuiDragDropFlags_None;
1756 DragDropAcceptIdCurrRectSurface = 0.0f;
1757 DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
1758 DragDropAcceptFrameCount = -1;
1759 DragDropHoldJustPressedId = 0;
1760 memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
1761
1762 CurrentTable = NULL;
1763 CurrentTableStackIdx = -1;
1764 CurrentTabBar = NULL;
1765
1766 LastValidMousePos = ImVec2(0.0f, 0.0f);
1767 TempInputId = 0;
1768 ColorEditOptions = ImGuiColorEditFlags_DefaultOptions_;
1769 ColorEditLastHue = ColorEditLastSat = 0.0f;
1770 ColorEditLastColor[0] = ColorEditLastColor[1] = ColorEditLastColor[2] = FLT_MAX;
1771 SliderCurrentAccum = 0.0f;
1772 SliderCurrentAccumDirty = false;
1773 DragCurrentAccumDirty = false;
1774 DragCurrentAccum = 0.0f;
1775 DragSpeedDefaultRatio = 1.0f / 100.0f;
1776 ScrollbarClickDeltaToGrabCenter = 0.0f;
1777 TooltipOverrideCount = 0;
1778 TooltipSlowDelay = 0.50f;
1779
1780 PlatformImePos = PlatformImeLastPos = ImVec2(FLT_MAX, FLT_MAX);
1781 PlatformLocaleDecimalPoint = '.';
1782
1783 SettingsLoaded = false;
1784 SettingsDirtyTimer = 0.0f;
1785 HookIdNext = 0;
1786
1787 LogEnabled = false;
1788 LogType = ImGuiLogType_None;
1789 LogNextPrefix = LogNextSuffix = NULL;
1790 LogFile = NULL;
1791 LogLinePosY = FLT_MAX;
1792 LogLineFirstItem = false;
1793 LogDepthRef = 0;
1794 LogDepthToExpand = LogDepthToExpandDefault = 2;
1795
1796 DebugItemPickerActive = false;
1797 DebugItemPickerBreakId = 0;
1798
1799 memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
1800 FramerateSecPerFrameIdx = FramerateSecPerFrameCount = 0;
1801 FramerateSecPerFrameAccum = 0.0f;
1802 WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
1803 memset(TempBuffer, 0, sizeof(TempBuffer));
1804 }
1805};
1806
1807//-----------------------------------------------------------------------------
1808// [SECTION] ImGuiWindowTempData, ImGuiWindow
1809//-----------------------------------------------------------------------------
1810
1811// Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.
1812// (That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered..)
1813// (This doesn't need a constructor because we zero-clear it as part of ImGuiWindow and all frame-temporary data are setup on Begin)
1814struct IMGUI_API ImGuiWindowTempData
1815{
1816 // Layout
1817 ImVec2 CursorPos; // Current emitting position, in absolute coordinates.
1818 ImVec2 CursorPosPrevLine;
1819 ImVec2 CursorStartPos; // Initial position after Begin(), generally ~ window position + WindowPadding.
1820 ImVec2 CursorMaxPos; // Used to implicitly calculate ContentSize at the beginning of next frame, for scrolling range and auto-resize. Always growing during the frame.
1821 ImVec2 IdealMaxPos; // Used to implicitly calculate ContentSizeIdeal at the beginning of next frame, for auto-resize only. Always growing during the frame.
1822 ImVec2 CurrLineSize;
1823 ImVec2 PrevLineSize;
1824 float CurrLineTextBaseOffset; // Baseline offset (0.0f by default on a new line, generally == style.FramePadding.y when a framed item has been added).
1825 float PrevLineTextBaseOffset;
1826 ImVec1 Indent; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
1827 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.
1828 ImVec1 GroupOffset;
1829
1830 // Keyboard/Gamepad navigation
1831 ImGuiNavLayer NavLayerCurrent; // Current layer, 0..31 (we currently only use 0..1)
1832 short NavLayersActiveMask; // Which layers have been written to (result from previous frame)
1833 short NavLayersActiveMaskNext;// Which layers have been written to (accumulator for current frame)
1834 ImGuiID NavFocusScopeIdCurrent; // Current focus scope ID while appending
1835 bool NavHideHighlightOneFrame;
1836 bool NavHasScroll; // Set when scrolling can be used (ScrollMax > 0.0f)
1837
1838 // Miscellaneous
1839 bool MenuBarAppending; // FIXME: Remove this
1840 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.
1841 ImGuiMenuColumns MenuColumns; // Simplified columns storage for menu items measurement
1842 int TreeDepth; // Current tree depth.
1843 ImU32 TreeJumpToParentOnPopMask; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31.. Could be turned into a ImU64 if necessary.
1844 ImVector<ImGuiWindow*> ChildWindows;
1845 ImGuiStorage* StateStorage; // Current persistent per-window storage (store e.g. tree node open/close state)
1846 ImGuiOldColumns* CurrentColumns; // Current columns set
1847 int CurrentTableIdx; // Current table index (into g.Tables)
1848 ImGuiLayoutType LayoutType;
1849 ImGuiLayoutType ParentLayoutType; // Layout type of parent window at the time of Begin()
1850 int FocusCounterRegular; // (Legacy Focus/Tabbing system) Sequential counter, start at -1 and increase as assigned via FocusableItemRegister() (FIXME-NAV: Needs redesign)
1851 int FocusCounterTabStop; // (Legacy Focus/Tabbing system) Same, but only count widgets which you can Tab through.
1852
1853 // Local parameters stacks
1854 // 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.
1855 float ItemWidth; // Current item width (>0.0: width in pixels, <0.0: align xx pixels to the right of window).
1856 float TextWrapPos; // Current text wrap pos.
1857 ImVector<float> ItemWidthStack; // Store item widths to restore (attention: .back() is not == ItemWidth)
1858 ImVector<float> TextWrapPosStack; // Store text wrap pos to restore (attention: .back() is not == TextWrapPos)
1859 ImGuiStackSizes StackSizesOnBegin; // Store size of various stacks for asserting
1860};
1861
1862// Storage for one window
1863struct IMGUI_API ImGuiWindow
1864{
1865 char* Name; // Window name, owned by the window.
1866 ImGuiID ID; // == ImHashStr(Name)
1867 ImGuiWindowFlags Flags; // See enum ImGuiWindowFlags_
1868 ImVec2 Pos; // Position (always rounded-up to nearest pixel)
1869 ImVec2 Size; // Current size (==SizeFull or collapsed title bar size)
1870 ImVec2 SizeFull; // Size when non collapsed
1871 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.
1872 ImVec2 ContentSizeIdeal;
1873 ImVec2 ContentSizeExplicit; // Size of contents/scrollable client area explicitly request by the user via SetNextWindowContentSize().
1874 ImVec2 WindowPadding; // Window padding at the time of Begin().
1875 float WindowRounding; // Window rounding at the time of Begin(). May be clamped lower to avoid rendering artifacts with title bar, menu bar etc.
1876 float WindowBorderSize; // Window border size at the time of Begin().
1877 int NameBufLen; // Size of buffer storing Name. May be larger than strlen(Name)!
1878 ImGuiID MoveId; // == window->GetID("#MOVE")
1879 ImGuiID ChildId; // ID of corresponding item in parent window (for navigation to return from child window to parent window)
1880 ImVec2 Scroll;
1881 ImVec2 ScrollMax;
1882 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)
1883 ImVec2 ScrollTargetCenterRatio; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
1884 ImVec2 ScrollTargetEdgeSnapDist; // 0.0f = no snapping, >0.0f snapping threshold
1885 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.
1886 bool ScrollbarX, ScrollbarY; // Are scrollbars visible?
1887 bool Active; // Set to true on Begin(), unless Collapsed
1888 bool WasActive;
1889 bool WriteAccessed; // Set to true when any widget access the current window
1890 bool Collapsed; // Set when collapsing window to become only title-bar
1891 bool WantCollapseToggle;
1892 bool SkipItems; // Set when items can safely be all clipped (e.g. window not visible or collapsed)
1893 bool Appearing; // Set during the frame where the window is appearing (or re-appearing)
1894 bool Hidden; // Do not display (== HiddenFrames*** > 0)
1895 bool IsFallbackWindow; // Set on the "Debug##Default" window.
1896 bool HasCloseButton; // Set when the window has a close button (p_open != NULL)
1897 signed char ResizeBorderHeld; // Current border being held for resize (-1: none, otherwise 0-3)
1898 short BeginCount; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
1899 short BeginOrderWithinParent; // Begin() order within immediate parent window, if we are a child window. Otherwise 0.
1900 short BeginOrderWithinContext; // Begin() order within entire imgui context. This is mostly used for debugging submission order related issues.
1901 short FocusOrder; // Order within WindowsFocusOrder[], altered when windows are focused.
1902 ImGuiID PopupId; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
1903 ImS8 AutoFitFramesX, AutoFitFramesY;
1904 ImS8 AutoFitChildAxises;
1905 bool AutoFitOnlyGrows;
1906 ImGuiDir AutoPosLastDirection;
1907 ImS8 HiddenFramesCanSkipItems; // Hide the window for N frames
1908 ImS8 HiddenFramesCannotSkipItems; // Hide the window for N frames while allowing items to be submitted so we can measure their size
1909 ImS8 HiddenFramesForRenderOnly; // Hide the window until frame N at Render() time only
1910 ImS8 DisableInputsFrames; // Disable window interactions for N frames
1911 ImGuiCond SetWindowPosAllowFlags : 8; // store acceptable condition flags for SetNextWindowPos() use.
1912 ImGuiCond SetWindowSizeAllowFlags : 8; // store acceptable condition flags for SetNextWindowSize() use.
1913 ImGuiCond SetWindowCollapsedAllowFlags : 8; // store acceptable condition flags for SetNextWindowCollapsed() use.
1914 ImVec2 SetWindowPosVal; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
1915 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.
1916
1917 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)
1918 ImGuiWindowTempData DC; // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name.
1919
1920 // The best way to understand what those rectangles are is to use the 'Metrics->Tools->Show Windows Rectangles' viewer.
1921 // The main 'OuterRect', omitted as a field, is window->Rect().
1922 ImRect OuterRectClipped; // == Window->Rect() just after setup in Begin(). == window->Rect() for root window.
1923 ImRect InnerRect; // Inner rectangle (omit title bar, menu bar, scroll bar)
1924 ImRect InnerClipRect; // == InnerRect shrunk by WindowPadding*0.5f on each side, clipped within viewport or parent clip rect.
1925 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).
1926 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?
1927 ImRect ClipRect; // Current clipping/scissoring rectangle, evolve as we are using PushClipRect(), etc. == DrawList->clip_rect_stack.back().
1928 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.
1929 ImVec2ih HitTestHoleSize; // Define an optional rectangular hole where mouse will pass-through the window.
1930 ImVec2ih HitTestHoleOffset;
1931
1932 int LastFrameActive; // Last frame number the window was Active.
1933 float LastTimeActive; // Last timestamp the window was Active (using float as we don't need high precision there)
1934 float ItemWidthDefault;
1935 ImGuiStorage StateStorage;
1936 ImVector<ImGuiOldColumns> ColumnsStorage;
1937 float FontWindowScale; // User scale multiplier per-window, via SetWindowFontScale()
1938 int SettingsOffset; // Offset into SettingsWindows[] (offsets are always valid as we only grow the array from the back)
1939
1940 ImDrawList* DrawList; // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)
1941 ImDrawList DrawListInst;
1942 ImGuiWindow* ParentWindow; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
1943 ImGuiWindow* RootWindow; // Point to ourself or first ancestor that is not a child window == Top-level window.
1944 ImGuiWindow* RootWindowForTitleBarHighlight; // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
1945 ImGuiWindow* RootWindowForNav; // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
1946
1947 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.)
1948 ImGuiID NavLastIds[ImGuiNavLayer_COUNT]; // Last known NavId for this window, per layer (0/1)
1949 ImRect NavRectRel[ImGuiNavLayer_COUNT]; // Reference rectangle, in window relative space
1950
1951 int MemoryDrawListIdxCapacity; // Backup of last idx/vtx count, so when waking up the window we can preallocate and avoid iterative alloc/copy
1952 int MemoryDrawListVtxCapacity;
1953 bool MemoryCompacted; // Set when window extraneous data have been garbage collected
1954
1955public:
1956 ImGuiWindow(ImGuiContext* context, const char* name);
1957 ~ImGuiWindow();
1958
1959 ImGuiID GetID(const char* str, const char* str_end = NULL);
1960 ImGuiID GetID(const void* ptr);
1961 ImGuiID GetID(int n);
1962 ImGuiID GetIDNoKeepAlive(const char* str, const char* str_end = NULL);
1963 ImGuiID GetIDNoKeepAlive(const void* ptr);
1964 ImGuiID GetIDNoKeepAlive(int n);
1965 ImGuiID GetIDFromRectangle(const ImRect& r_abs);
1966
1967 // We don't use g.FontSize because the window may be != g.CurrentWidow.
1968 ImRect Rect() const { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
1969 float CalcFontSize() const { ImGuiContext& g = *GImGui; float scale = g.FontBaseSize * FontWindowScale; if (ParentWindow) scale *= ParentWindow->FontWindowScale; return scale; }
1970 float TitleBarHeight() const { ImGuiContext& g = *GImGui; return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + g.Style.FramePadding.y * 2.0f; }
1971 ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
1972 float MenuBarHeight() const { ImGuiContext& g = *GImGui; return (Flags & ImGuiWindowFlags_MenuBar) ? DC.MenuBarOffset.y + CalcFontSize() + g.Style.FramePadding.y * 2.0f : 0.0f; }
1973 ImRect MenuBarRect() const { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
1974};
1975
1976//-----------------------------------------------------------------------------
1977// [SECTION] Tab bar, Tab item support
1978//-----------------------------------------------------------------------------
1979
1980// Extend ImGuiTabBarFlags_
1981enum ImGuiTabBarFlagsPrivate_
1982{
1983 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]
1984 ImGuiTabBarFlags_IsFocused = 1 << 21,
1985 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
1986};
1987
1988// Extend ImGuiTabItemFlags_
1989enum ImGuiTabItemFlagsPrivate_
1990{
1991 ImGuiTabItemFlags_SectionMask_ = ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing,
1992 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)
1993 ImGuiTabItemFlags_Button = 1 << 21 // Used by TabItemButton, change the tab item behavior to mimic a button
1994};
1995
1996// Storage for one active tab item (sizeof() 40 bytes)
1997struct ImGuiTabItem
1998{
1999 ImGuiID ID;
2000 ImGuiTabItemFlags Flags;
2001 int LastFrameVisible;
2002 int LastFrameSelected; // This allows us to infer an ordered list of the last activated tabs with little maintenance
2003 float Offset; // Position relative to beginning of tab
2004 float Width; // Width currently displayed
2005 float ContentWidth; // Width of label, stored during BeginTabItem() call
2006 ImS32 NameOffset; // When Window==NULL, offset to name within parent ImGuiTabBar::TabsNames
2007 ImS16 BeginOrder; // BeginTabItem() order, used to re-order tabs after toggling ImGuiTabBarFlags_Reorderable
2008 ImS16 IndexDuringLayout; // Index only used during TabBarLayout()
2009 bool WantClose; // Marked as closed by SetTabItemClosed()
2010
2011 ImGuiTabItem() { memset(this, 0, sizeof(*this)); LastFrameVisible = LastFrameSelected = -1; NameOffset = -1; BeginOrder = IndexDuringLayout = -1; }
2012};
2013
2014// Storage for a tab bar (sizeof() 152 bytes)
2015struct ImGuiTabBar
2016{
2017 ImVector<ImGuiTabItem> Tabs;
2018 ImGuiTabBarFlags Flags;
2019 ImGuiID ID; // Zero for tab-bars used by docking
2020 ImGuiID SelectedTabId; // Selected tab/window
2021 ImGuiID NextSelectedTabId; // Next selected tab/window. Will also trigger a scrolling animation
2022 ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)
2023 int CurrFrameVisible;
2024 int PrevFrameVisible;
2025 ImRect BarRect;
2026 float CurrTabsContentsHeight;
2027 float PrevTabsContentsHeight; // Record the height of contents submitted below the tab bar
2028 float WidthAllTabs; // Actual width of all tabs (locked during layout)
2029 float WidthAllTabsIdeal; // Ideal width if all tabs were visible and not clipped
2030 float ScrollingAnim;
2031 float ScrollingTarget;
2032 float ScrollingTargetDistToVisibility;
2033 float ScrollingSpeed;
2034 float ScrollingRectMinX;
2035 float ScrollingRectMaxX;
2036 ImGuiID ReorderRequestTabId;
2037 ImS16 ReorderRequestOffset;
2038 ImS8 BeginCount;
2039 bool WantLayout;
2040 bool VisibleTabWasSubmitted;
2041 bool TabsAddedNew; // Set to true when a new tab item or button has been added to the tab bar during last frame
2042 ImS16 TabsActiveCount; // Number of tabs submitted this frame.
2043 ImS16 LastTabItemIdx; // Index of last BeginTabItem() tab for use by EndTabItem()
2044 float ItemSpacingY;
2045 ImVec2 FramePadding; // style.FramePadding locked at the time of BeginTabBar()
2046 ImVec2 BackupCursorPos;
2047 ImGuiTextBuffer TabsNames; // For non-docking tab bar we re-append names in a contiguous buffer.
2048
2049 ImGuiTabBar();
2050 int GetTabOrder(const ImGuiTabItem* tab) const { return Tabs.index_from_ptr(tab); }
2051 const char* GetTabName(const ImGuiTabItem* tab) const
2052 {
2053 IM_ASSERT(tab->NameOffset != -1 && tab->NameOffset < TabsNames.Buf.Size);
2054 return TabsNames.Buf.Data + tab->NameOffset;
2055 }
2056};
2057
2058//-----------------------------------------------------------------------------
2059// [SECTION] Table support
2060//-----------------------------------------------------------------------------
2061
2062#define IM_COL32_DISABLE IM_COL32(0,0,0,1) // Special sentinel code which cannot be used as a regular color.
2063#define IMGUI_TABLE_MAX_COLUMNS 64 // sizeof(ImU64) * 8. This is solely because we frequently encode columns set in a ImU64.
2064#define IMGUI_TABLE_MAX_DRAW_CHANNELS (4 + 64 * 2) // See TableSetupDrawChannels()
2065
2066// Our current column maximum is 64 but we may raise that in the future.
2067typedef ImS8 ImGuiTableColumnIdx;
2068typedef ImU8 ImGuiTableDrawChannelIdx;
2069
2070// [Internal] sizeof() ~ 104
2071// We use the terminology "Enabled" to refer to a column that is not Hidden by user/api.
2072// We use the terminology "Clipped" to refer to a column that is out of sight because of scrolling/clipping.
2073// This is in contrast with some user-facing api such as IsItemVisible() / IsRectVisible() which use "Visible" to mean "not clipped".
2074struct ImGuiTableColumn
2075{
2076 ImGuiTableColumnFlags Flags; // Flags after some patching (not directly same as provided by user). See ImGuiTableColumnFlags_
2077 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.
2078 float MinX; // Absolute positions
2079 float MaxX;
2080 float WidthRequest; // Master width absolute value when !(Flags & _WidthStretch). When Stretch this is derived every frame from StretchWeight in TableUpdateLayout()
2081 float WidthAuto; // Automatic width
2082 float StretchWeight; // Master width weight when (Flags & _WidthStretch). Often around ~1.0f initially.
2083 float InitStretchWeightOrWidth; // Value passed to TableSetupColumn(). For Width it is a content width (_without padding_).
2084 ImRect ClipRect; // Clipping rectangle for the column
2085 ImGuiID UserID; // Optional, value passed to TableSetupColumn()
2086 float WorkMinX; // Contents region min ~(MinX + CellPaddingX + CellSpacingX1) == cursor start position when entering column
2087 float WorkMaxX; // Contents region max ~(MaxX - CellPaddingX - CellSpacingX2)
2088 float ItemWidth; // Current item width for the column, preserved across rows
2089 float ContentMaxXFrozen; // Contents maximum position for frozen rows (apart from headers), from which we can infer content width.
2090 float ContentMaxXUnfrozen;
2091 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
2092 float ContentMaxXHeadersIdeal;
2093 ImS16 NameOffset; // Offset into parent ColumnsNames[]
2094 ImGuiTableColumnIdx DisplayOrder; // Index within Table's IndexToDisplayOrder[] (column may be reordered by users)
2095 ImGuiTableColumnIdx IndexWithinEnabledSet; // Index within enabled/visible set (<= IndexToDisplayOrder)
2096 ImGuiTableColumnIdx PrevEnabledColumn; // Index of prev enabled/visible column within Columns[], -1 if first enabled/visible column
2097 ImGuiTableColumnIdx NextEnabledColumn; // Index of next enabled/visible column within Columns[], -1 if last enabled/visible column
2098 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
2099 ImGuiTableDrawChannelIdx DrawChannelCurrent; // Index within DrawSplitter.Channels[]
2100 ImGuiTableDrawChannelIdx DrawChannelFrozen; // Draw channels for frozen rows (often headers)
2101 ImGuiTableDrawChannelIdx DrawChannelUnfrozen; // Draw channels for unfrozen rows
2102 bool IsEnabled; // IsUserEnabled && (Flags & ImGuiTableColumnFlags_Disabled) == 0
2103 bool IsUserEnabled; // Is the column not marked Hidden by the user? (unrelated to being off view, e.g. clipped by scrolling).
2104 bool IsUserEnabledNextFrame;
2105 bool IsVisibleX; // Is actually in view (e.g. overlapping the host window clipping rectangle, not scrolled).
2106 bool IsVisibleY;
2107 bool IsRequestOutput; // Return value for TableSetColumnIndex() / TableNextColumn(): whether we request user to output contents or not.
2108 bool IsSkipItems; // Do we want item submissions to this column to be completely ignored (no layout will happen).
2109 bool IsPreserveWidthAuto;
2110 ImS8 NavLayerCurrent; // ImGuiNavLayer in 1 byte
2111 ImU8 AutoFitQueue; // Queue of 8 values for the next 8 frames to request auto-fit
2112 ImU8 CannotSkipItemsQueue; // Queue of 8 values for the next 8 frames to disable Clipped/SkipItem
2113 ImU8 SortDirection : 2; // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending
2114 ImU8 SortDirectionsAvailCount : 2; // Number of available sort directions (0 to 3)
2115 ImU8 SortDirectionsAvailMask : 4; // Mask of available sort directions (1-bit each)
2116 ImU8 SortDirectionsAvailList; // Ordered of available sort directions (2-bits each)
2117
2118 ImGuiTableColumn()
2119 {
2120 memset(this, 0, sizeof(*this));
2121 StretchWeight = WidthRequest = -1.0f;
2122 NameOffset = -1;
2123 DisplayOrder = IndexWithinEnabledSet = -1;
2124 PrevEnabledColumn = NextEnabledColumn = -1;
2125 SortOrder = -1;
2126 SortDirection = ImGuiSortDirection_None;
2127 DrawChannelCurrent = DrawChannelFrozen = DrawChannelUnfrozen = (ImU8)-1;
2128 }
2129};
2130
2131// Transient cell data stored per row.
2132// sizeof() ~ 6
2133struct ImGuiTableCellData
2134{
2135 ImU32 BgColor; // Actual color
2136 ImGuiTableColumnIdx Column; // Column number
2137};
2138
2139// FIXME-TABLE: more transient data could be stored in a per-stacked table structure: DrawSplitter, SortSpecs, incoming RowData
2140struct ImGuiTable
2141{
2142 ImGuiID ID;
2143 ImGuiTableFlags Flags;
2144 void* RawData; // Single allocation to hold Columns[], DisplayOrderToIndex[] and RowCellData[]
2145 ImGuiTableTempData* TempData; // Transient data while table is active. Point within g.CurrentTableStack[]
2146 ImSpan<ImGuiTableColumn> Columns; // Point within RawData[]
2147 ImSpan<ImGuiTableColumnIdx> DisplayOrderToIndex; // Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1)
2148 ImSpan<ImGuiTableCellData> RowCellData; // Point within RawData[]. Store cells background requests for current row.
2149 ImU64 EnabledMaskByDisplayOrder; // Column DisplayOrder -> IsEnabled map
2150 ImU64 EnabledMaskByIndex; // Column Index -> IsEnabled map (== not hidden by user/api) in a format adequate for iterating column without touching cold data
2151 ImU64 VisibleMaskByIndex; // Column Index -> IsVisibleX|IsVisibleY map (== not hidden by user/api && not hidden by scrolling/cliprect)
2152 ImU64 RequestOutputMaskByIndex; // Column Index -> IsVisible || AutoFit (== expect user to submit items)
2153 ImGuiTableFlags SettingsLoadedFlags; // Which data were loaded from the .ini file (e.g. when order is not altered we won't save order)
2154 int SettingsOffset; // Offset in g.SettingsTables
2155 int LastFrameActive;
2156 int ColumnsCount; // Number of columns declared in BeginTable()
2157 int CurrentRow;
2158 int CurrentColumn;
2159 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.
2160 ImS16 InstanceInteracted; // Mark which instance (generally 0) of the same ID is being interacted with
2161 float RowPosY1;
2162 float RowPosY2;
2163 float RowMinHeight; // Height submitted to TableNextRow()
2164 float RowTextBaseline;
2165 float RowIndentOffsetX;
2166 ImGuiTableRowFlags RowFlags : 16; // Current row flags, see ImGuiTableRowFlags_
2167 ImGuiTableRowFlags LastRowFlags : 16;
2168 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.
2169 ImU32 RowBgColor[2]; // Background color override for current row.
2170 ImU32 BorderColorStrong;
2171 ImU32 BorderColorLight;
2172 float BorderX1;
2173 float BorderX2;
2174 float HostIndentX;
2175 float MinColumnWidth;
2176 float OuterPaddingX;
2177 float CellPaddingX; // Padding from each borders
2178 float CellPaddingY;
2179 float CellSpacingX1; // Spacing between non-bordered cells
2180 float CellSpacingX2;
2181 float LastOuterHeight; // Outer height from last frame
2182 float LastFirstRowHeight; // Height of first row from last frame
2183 float InnerWidth; // User value passed to BeginTable(), see comments at the top of BeginTable() for details.
2184 float ColumnsGivenWidth; // Sum of current column width
2185 float ColumnsAutoFitWidth; // Sum of ideal column width in order nothing to be clipped, used for auto-fitting and content width submission in outer window
2186 float ResizedColumnNextWidth;
2187 float ResizeLockMinContentsX2; // Lock minimum contents width while resizing down in order to not create feedback loops. But we allow growing the table.
2188 float RefScale; // Reference scale to be able to rescale columns on font/dpi changes.
2189 ImRect OuterRect; // Note: for non-scrolling table, OuterRect.Max.y is often FLT_MAX until EndTable(), unless a height has been specified in BeginTable().
2190 ImRect InnerRect; // InnerRect but without decoration. As with OuterRect, for non-scrolling tables, InnerRect.Max.y is
2191 ImRect WorkRect;
2192 ImRect InnerClipRect;
2193 ImRect BgClipRect; // We use this to cpu-clip cell background color fill
2194 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
2195 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.
2196 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.
2197 ImRect HostBackupInnerClipRect; // Backup of InnerWindow->ClipRect during PushTableBackground()/PopTableBackground()
2198 ImGuiWindow* OuterWindow; // Parent window for the table
2199 ImGuiWindow* InnerWindow; // Window holding the table data (== OuterWindow or a child window)
2200 ImGuiTextBuffer ColumnsNames; // Contiguous buffer holding columns names
2201 ImDrawListSplitter* DrawSplitter; // Shortcut to TempData->DrawSplitter while in table. Isolate draw commands per columns to avoid switching clip rect constantly
2202 ImGuiTableColumnSortSpecs SortSpecsSingle;
2203 ImVector<ImGuiTableColumnSortSpecs> SortSpecsMulti; // FIXME-OPT: Using a small-vector pattern would be good.
2204 ImGuiTableSortSpecs SortSpecs; // Public facing sorts specs, this is what we return in TableGetSortSpecs()
2205 ImGuiTableColumnIdx SortSpecsCount;
2206 ImGuiTableColumnIdx ColumnsEnabledCount; // Number of enabled columns (<= ColumnsCount)
2207 ImGuiTableColumnIdx ColumnsEnabledFixedCount; // Number of enabled columns (<= ColumnsCount)
2208 ImGuiTableColumnIdx DeclColumnsCount; // Count calls to TableSetupColumn()
2209 ImGuiTableColumnIdx HoveredColumnBody; // Index of column whose visible region is being hovered. Important: == ColumnsCount when hovering empty region after the right-most column!
2210 ImGuiTableColumnIdx HoveredColumnBorder; // Index of column whose right-border is being hovered (for resizing).
2211 ImGuiTableColumnIdx AutoFitSingleColumn; // Index of single column requesting auto-fit.
2212 ImGuiTableColumnIdx ResizedColumn; // Index of column being resized. Reset when InstanceCurrent==0.
2213 ImGuiTableColumnIdx LastResizedColumn; // Index of column being resized from previous frame.
2214 ImGuiTableColumnIdx HeldHeaderColumn; // Index of column header being held.
2215 ImGuiTableColumnIdx ReorderColumn; // Index of column being reordered. (not cleared)
2216 ImGuiTableColumnIdx ReorderColumnDir; // -1 or +1
2217 ImGuiTableColumnIdx LeftMostEnabledColumn; // Index of left-most non-hidden column.
2218 ImGuiTableColumnIdx RightMostEnabledColumn; // Index of right-most non-hidden column.
2219 ImGuiTableColumnIdx LeftMostStretchedColumn; // Index of left-most stretched column.
2220 ImGuiTableColumnIdx RightMostStretchedColumn; // Index of right-most stretched column.
2221 ImGuiTableColumnIdx ContextPopupColumn; // Column right-clicked on, of -1 if opening context menu from a neutral/empty spot
2222 ImGuiTableColumnIdx FreezeRowsRequest; // Requested frozen rows count
2223 ImGuiTableColumnIdx FreezeRowsCount; // Actual frozen row count (== FreezeRowsRequest, or == 0 when no scrolling offset)
2224 ImGuiTableColumnIdx FreezeColumnsRequest; // Requested frozen columns count
2225 ImGuiTableColumnIdx FreezeColumnsCount; // Actual frozen columns count (== FreezeColumnsRequest, or == 0 when no scrolling offset)
2226 ImGuiTableColumnIdx RowCellDataCurrent; // Index of current RowCellData[] entry in current row
2227 ImGuiTableDrawChannelIdx DummyDrawChannel; // Redirect non-visible columns here.
2228 ImGuiTableDrawChannelIdx Bg2DrawChannelCurrent; // For Selectable() and other widgets drawing across columns after the freezing line. Index within DrawSplitter.Channels[]
2229 ImGuiTableDrawChannelIdx Bg2DrawChannelUnfrozen;
2230 bool IsLayoutLocked; // Set by TableUpdateLayout() which is called when beginning the first row.
2231 bool IsInsideRow; // Set when inside TableBeginRow()/TableEndRow().
2232 bool IsInitializing;
2233 bool IsSortSpecsDirty;
2234 bool IsUsingHeaders; // Set when the first row had the ImGuiTableRowFlags_Headers flag.
2235 bool IsContextPopupOpen; // Set when default context menu is open (also see: ContextPopupColumn, InstanceInteracted).
2236 bool IsSettingsRequestLoad;
2237 bool IsSettingsDirty; // Set when table settings have changed and needs to be reported into ImGuiTableSetttings data.
2238 bool IsDefaultDisplayOrder; // Set when display order is unchanged from default (DisplayOrder contains 0...Count-1)
2239 bool IsResetAllRequest;
2240 bool IsResetDisplayOrderRequest;
2241 bool IsUnfrozenRows; // Set when we got past the frozen row.
2242 bool IsDefaultSizingPolicy; // Set if user didn't explicitly set a sizing policy in BeginTable()
2243 bool MemoryCompacted;
2244 bool HostSkipItems; // Backup of InnerWindow->SkipItem at the end of BeginTable(), because we will overwrite InnerWindow->SkipItem on a per-column basis
2245
2246 IMGUI_API ImGuiTable() { memset(this, 0, sizeof(*this)); LastFrameActive = -1; }
2247 IMGUI_API ~ImGuiTable() { IM_FREE(RawData); }
2248};
2249
2250// Transient data that are only needed between BeginTable() and EndTable(), those buffers are shared (1 per level of stacked table).
2251// - Accessing those requires chasing an extra pointer so for very frequently used data we leave them in the main table structure.
2252// - We also leave out of this structure data that tend to be particularly useful for debugging/metrics.
2253struct ImGuiTableTempData
2254{
2255 int TableIndex; // Index in g.Tables.Buf[] pool
2256 float LastTimeActive; // Last timestamp this structure was used
2257
2258 ImVec2 UserOuterSize; // outer_size.x passed to BeginTable()
2259 ImDrawListSplitter DrawSplitter;
2260
2261 ImRect HostBackupWorkRect; // Backup of InnerWindow->WorkRect at the end of BeginTable()
2262 ImRect HostBackupParentWorkRect; // Backup of InnerWindow->ParentWorkRect at the end of BeginTable()
2263 ImVec2 HostBackupPrevLineSize; // Backup of InnerWindow->DC.PrevLineSize at the end of BeginTable()
2264 ImVec2 HostBackupCurrLineSize; // Backup of InnerWindow->DC.CurrLineSize at the end of BeginTable()
2265 ImVec2 HostBackupCursorMaxPos; // Backup of InnerWindow->DC.CursorMaxPos at the end of BeginTable()
2266 ImVec1 HostBackupColumnsOffset; // Backup of OuterWindow->DC.ColumnsOffset at the end of BeginTable()
2267 float HostBackupItemWidth; // Backup of OuterWindow->DC.ItemWidth at the end of BeginTable()
2268 int HostBackupItemWidthStackSize;//Backup of OuterWindow->DC.ItemWidthStack.Size at the end of BeginTable()
2269
2270 IMGUI_API ImGuiTableTempData() { memset(this, 0, sizeof(*this)); LastTimeActive = -1.0f; }
2271};
2272
2273// sizeof() ~ 12
2274struct ImGuiTableColumnSettings
2275{
2276 float WidthOrWeight;
2277 ImGuiID UserID;
2278 ImGuiTableColumnIdx Index;
2279 ImGuiTableColumnIdx DisplayOrder;
2280 ImGuiTableColumnIdx SortOrder;
2281 ImU8 SortDirection : 2;
2282 ImU8 IsEnabled : 1; // "Visible" in ini file
2283 ImU8 IsStretch : 1;
2284
2285 ImGuiTableColumnSettings()
2286 {
2287 WidthOrWeight = 0.0f;
2288 UserID = 0;
2289 Index = -1;
2290 DisplayOrder = SortOrder = -1;
2291 SortDirection = ImGuiSortDirection_None;
2292 IsEnabled = 1;
2293 IsStretch = 0;
2294 }
2295};
2296
2297// This is designed to be stored in a single ImChunkStream (1 header followed by N ImGuiTableColumnSettings, etc.)
2298struct ImGuiTableSettings
2299{
2300 ImGuiID ID; // Set to 0 to invalidate/delete the setting
2301 ImGuiTableFlags SaveFlags; // Indicate data we want to save using the Resizable/Reorderable/Sortable/Hideable flags (could be using its own flags..)
2302 float RefScale; // Reference scale to be able to rescale columns on font/dpi changes.
2303 ImGuiTableColumnIdx ColumnsCount;
2304 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
2305 bool WantApply; // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)
2306
2307 ImGuiTableSettings() { memset(this, 0, sizeof(*this)); }
2308 ImGuiTableColumnSettings* GetColumnSettings() { return (ImGuiTableColumnSettings*)(this + 1); }
2309};
2310
2311//-----------------------------------------------------------------------------
2312// [SECTION] ImGui internal API
2313// No guarantee of forward compatibility here!
2314//-----------------------------------------------------------------------------
2315
2316namespace ImGui
2317{
2318 // Windows
2319 // We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
2320 // If this ever crash because g.CurrentWindow is NULL it means that either
2321 // - ImGui::NewFrame() has never been called, which is illegal.
2322 // - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
2323 inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; }
2324 inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
2325 IMGUI_API ImGuiWindow* FindWindowByID(ImGuiID id);
2326 IMGUI_API ImGuiWindow* FindWindowByName(const char* name);
2327 IMGUI_API void UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window);
2328 IMGUI_API ImVec2 CalcWindowNextAutoFitSize(ImGuiWindow* window);
2329 IMGUI_API bool IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent);
2330 IMGUI_API bool IsWindowAbove(ImGuiWindow* potential_above, ImGuiWindow* potential_below);
2331 IMGUI_API bool IsWindowNavFocusable(ImGuiWindow* window);
2332 IMGUI_API void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiCond cond = 0);
2333 IMGUI_API void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond = 0);
2334 IMGUI_API void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiCond cond = 0);
2335 IMGUI_API void SetWindowHitTestHole(ImGuiWindow* window, const ImVec2& pos, const ImVec2& size);
2336
2337 // Windows: Display Order and Focus Order
2338 IMGUI_API void FocusWindow(ImGuiWindow* window);
2339 IMGUI_API void FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window);
2340 IMGUI_API void BringWindowToFocusFront(ImGuiWindow* window);
2341 IMGUI_API void BringWindowToDisplayFront(ImGuiWindow* window);
2342 IMGUI_API void BringWindowToDisplayBack(ImGuiWindow* window);
2343
2344 // Fonts, drawing
2345 IMGUI_API void SetCurrentFont(ImFont* font);
2346 inline ImFont* GetDefaultFont() { ImGuiContext& g = *GImGui; return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }
2347 inline ImDrawList* GetForegroundDrawList(ImGuiWindow* window) { IM_UNUSED(window); return GetForegroundDrawList(); } // This seemingly unnecessary wrapper simplifies compatibility between the 'master' and 'docking' branches.
2348 IMGUI_API ImDrawList* GetBackgroundDrawList(ImGuiViewport* viewport); // get background draw list for the given viewport. this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
2349 IMGUI_API ImDrawList* GetForegroundDrawList(ImGuiViewport* viewport); // get foreground draw list for the given viewport. this draw list will be the last rendered one. Useful to quickly draw shapes/text over dear imgui contents.
2350
2351 // Init
2352 IMGUI_API void Initialize(ImGuiContext* context);
2353 IMGUI_API void Shutdown(ImGuiContext* context); // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
2354
2355 // NewFrame
2356 IMGUI_API void UpdateHoveredWindowAndCaptureFlags();
2357 IMGUI_API void StartMouseMovingWindow(ImGuiWindow* window);
2358 IMGUI_API void UpdateMouseMovingWindowNewFrame();
2359 IMGUI_API void UpdateMouseMovingWindowEndFrame();
2360
2361 // Generic context hooks
2362 IMGUI_API ImGuiID AddContextHook(ImGuiContext* context, const ImGuiContextHook* hook);
2363 IMGUI_API void RemoveContextHook(ImGuiContext* context, ImGuiID hook_to_remove);
2364 IMGUI_API void CallContextHooks(ImGuiContext* context, ImGuiContextHookType type);
2365
2366 // Settings
2367 IMGUI_API void MarkIniSettingsDirty();
2368 IMGUI_API void MarkIniSettingsDirty(ImGuiWindow* window);
2369 IMGUI_API void ClearIniSettings();
2370 IMGUI_API ImGuiWindowSettings* CreateNewWindowSettings(const char* name);
2371 IMGUI_API ImGuiWindowSettings* FindWindowSettings(ImGuiID id);
2372 IMGUI_API ImGuiWindowSettings* FindOrCreateWindowSettings(const char* name);
2373 IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
2374
2375 // Scrolling
2376 IMGUI_API void SetNextWindowScroll(const ImVec2& scroll); // Use -1.0f on one axis to leave as-is
2377 IMGUI_API void SetScrollX(ImGuiWindow* window, float scroll_x);
2378 IMGUI_API void SetScrollY(ImGuiWindow* window, float scroll_y);
2379 IMGUI_API void SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio);
2380 IMGUI_API void SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio);
2381 IMGUI_API ImVec2 ScrollToBringRectIntoView(ImGuiWindow* window, const ImRect& item_rect);
2382
2383 // Basic Accessors
2384 inline ImGuiID GetItemID() { ImGuiContext& g = *GImGui; return g.LastItemData.ID; } // Get ID of last item (~~ often same ImGui::GetID(label) beforehand)
2385 inline ImGuiItemStatusFlags GetItemStatusFlags(){ ImGuiContext& g = *GImGui; return g.LastItemData.StatusFlags; }
2386 inline ImGuiItemFlags GetItemFlags() { ImGuiContext& g = *GImGui; return g.LastItemData.InFlags; }
2387 inline ImGuiID GetActiveID() { ImGuiContext& g = *GImGui; return g.ActiveId; }
2388 inline ImGuiID GetFocusID() { ImGuiContext& g = *GImGui; return g.NavId; }
2389 IMGUI_API void SetActiveID(ImGuiID id, ImGuiWindow* window);
2390 IMGUI_API void SetFocusID(ImGuiID id, ImGuiWindow* window);
2391 IMGUI_API void ClearActiveID();
2392 IMGUI_API ImGuiID GetHoveredID();
2393 IMGUI_API void SetHoveredID(ImGuiID id);
2394 IMGUI_API void KeepAliveID(ImGuiID id);
2395 IMGUI_API void MarkItemEdited(ImGuiID id); // Mark data associated to given item as "edited", used by IsItemDeactivatedAfterEdit() function.
2396 IMGUI_API void PushOverrideID(ImGuiID id); // Push given value as-is at the top of the ID stack (whereas PushID combines old and new hashes)
2397 IMGUI_API ImGuiID GetIDWithSeed(const char* str_id_begin, const char* str_id_end, ImGuiID seed);
2398
2399 // Basic Helpers for widget code
2400 IMGUI_API void ItemSize(const ImVec2& size, float text_baseline_y = -1.0f);
2401 IMGUI_API void ItemSize(const ImRect& bb, float text_baseline_y = -1.0f);
2402 IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb = NULL, ImGuiItemAddFlags flags = 0);
2403 IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id);
2404 IMGUI_API void ItemFocusable(ImGuiWindow* window, ImGuiID id);
2405 IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
2406 IMGUI_API ImVec2 CalcItemSize(ImVec2 size, float default_w, float default_h);
2407 IMGUI_API float CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
2408 IMGUI_API void PushMultiItemsWidths(int components, float width_full);
2409 IMGUI_API bool IsItemToggledSelection(); // Was the last item selection toggled? (after Selectable(), TreeNode() etc. We only returns toggle _event_ in order to handle clipping correctly)
2410 IMGUI_API ImVec2 GetContentRegionMaxAbs();
2411 IMGUI_API void ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess);
2412
2413 // Parameter stacks
2414 IMGUI_API void PushItemFlag(ImGuiItemFlags option, bool enabled);
2415 IMGUI_API void PopItemFlag();
2416 IMGUI_API void PushDisabled(bool disabled = true);
2417 IMGUI_API void PopDisabled();
2418
2419#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
2420 // If you have old/custom copy-and-pasted widgets that used FocusableItemRegister():
2421 // (Old) IMGUI_VERSION_NUM < 18209: using 'ItemAdd(....)' and 'bool focused = FocusableItemRegister(...)'
2422 // (New) IMGUI_VERSION_NUM >= 18209: using 'ItemAdd(..., ImGuiItemAddFlags_Focusable)' and 'bool focused = (GetItemStatusFlags() & ImGuiItemStatusFlags_Focused) != 0'
2423 // Widget code are simplified as there's no need to call FocusableItemUnregister() while managing the transition from regular widget to TempInputText()
2424 inline bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id) { IM_ASSERT(0); IM_UNUSED(window); IM_UNUSED(id); return false; } // -> pass ImGuiItemAddFlags_Focusable flag to ItemAdd()
2425 inline void FocusableItemUnregister(ImGuiWindow* window) { IM_ASSERT(0); IM_UNUSED(window); } // -> unnecessary: TempInputText() uses ImGuiInputTextFlags_MergedItem
2426#endif
2427
2428 // Logging/Capture
2429 IMGUI_API void LogBegin(ImGuiLogType type, int auto_open_depth); // -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name.
2430 IMGUI_API void LogToBuffer(int auto_open_depth = -1); // Start logging/capturing to internal buffer
2431 IMGUI_API void LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end = NULL);
2432 IMGUI_API void LogSetNextTextDecoration(const char* prefix, const char* suffix);
2433
2434 // Popups, Modals, Tooltips
2435 IMGUI_API bool BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, bool border, ImGuiWindowFlags flags);
2436 IMGUI_API void OpenPopupEx(ImGuiID id, ImGuiPopupFlags popup_flags = ImGuiPopupFlags_None);
2437 IMGUI_API void ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup);
2438 IMGUI_API void ClosePopupsOverWindow(ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup);
2439 IMGUI_API bool IsPopupOpen(ImGuiID id, ImGuiPopupFlags popup_flags);
2440 IMGUI_API bool BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags);
2441 IMGUI_API void BeginTooltipEx(ImGuiWindowFlags extra_flags, ImGuiTooltipFlags tooltip_flags);
2442 IMGUI_API ImRect GetPopupAllowedExtentRect(ImGuiWindow* window);
2443 IMGUI_API ImGuiWindow* GetTopMostPopupModal();
2444 IMGUI_API ImVec2 FindBestWindowPosForPopup(ImGuiWindow* window);
2445 IMGUI_API ImVec2 FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy);
2446 IMGUI_API bool BeginViewportSideBar(const char* name, ImGuiViewport* viewport, ImGuiDir dir, float size, ImGuiWindowFlags window_flags);
2447
2448 // Menus
2449 IMGUI_API bool MenuItemEx(const char* label, const char* icon, const char* shortcut = NULL, bool selected = false, bool enabled = true);
2450
2451 // Combos
2452 IMGUI_API bool BeginComboPopup(ImGuiID popup_id, const ImRect& bb, ImGuiComboFlags flags);
2453 IMGUI_API bool BeginComboPreview();
2454 IMGUI_API void EndComboPreview();
2455
2456 // Gamepad/Keyboard Navigation
2457 IMGUI_API void NavInitWindow(ImGuiWindow* window, bool force_reinit);
2458 IMGUI_API bool NavMoveRequestButNoResultYet();
2459 IMGUI_API void NavMoveRequestCancel();
2460 IMGUI_API void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect& bb_rel, ImGuiNavMoveFlags move_flags);
2461 IMGUI_API void NavMoveRequestTryWrapping(ImGuiWindow* window, ImGuiNavMoveFlags move_flags);
2462 IMGUI_API float GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode);
2463 IMGUI_API ImVec2 GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor = 0.0f, float fast_factor = 0.0f);
2464 IMGUI_API int CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate);
2465 IMGUI_API void ActivateItem(ImGuiID id); // Remotely activate a button, checkbox, tree node etc. given its unique ID. activation is queued and processed on the next frame when the item is encountered again.
2466 IMGUI_API void SetNavID(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel);
2467
2468 // Focus Scope (WIP)
2469 // This is generally used to identify a selection set (multiple of which may be in the same window), as selection
2470 // patterns generally need to react (e.g. clear selection) when landing on an item of the set.
2471 IMGUI_API void PushFocusScope(ImGuiID id);
2472 IMGUI_API void PopFocusScope();
2473 inline ImGuiID GetFocusedFocusScope() { ImGuiContext& g = *GImGui; return g.NavFocusScopeId; } // Focus scope which is actually active
2474 inline ImGuiID GetFocusScope() { ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.NavFocusScopeIdCurrent; } // Focus scope we are outputting into, set by PushFocusScope()
2475
2476 // Inputs
2477 // FIXME: Eventually we should aim to move e.g. IsActiveIdUsingKey() into IsKeyXXX functions.
2478 IMGUI_API void SetItemUsingMouseWheel();
2479 IMGUI_API void SetActiveIdUsingNavAndKeys();
2480 inline bool IsActiveIdUsingNavDir(ImGuiDir dir) { ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavDirMask & (1 << dir)) != 0; }
2481 inline bool IsActiveIdUsingNavInput(ImGuiNavInput input) { ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavInputMask & (1 << input)) != 0; }
2482 inline bool IsActiveIdUsingKey(ImGuiKey key) { ImGuiContext& g = *GImGui; IM_ASSERT(key < 64); return (g.ActiveIdUsingKeyInputMask & ((ImU64)1 << key)) != 0; }
2483 IMGUI_API bool IsMouseDragPastThreshold(ImGuiMouseButton button, float lock_threshold = -1.0f);
2484 inline bool IsKeyPressedMap(ImGuiKey key, bool repeat = true) { ImGuiContext& g = *GImGui; const int key_index = g.IO.KeyMap[key]; return (key_index >= 0) ? IsKeyPressed(key_index, repeat) : false; }
2485 inline bool IsNavInputDown(ImGuiNavInput n) { ImGuiContext& g = *GImGui; return g.IO.NavInputs[n] > 0.0f; }
2486 inline bool IsNavInputTest(ImGuiNavInput n, ImGuiInputReadMode rm) { return (GetNavInputAmount(n, rm) > 0.0f); }
2487 IMGUI_API ImGuiKeyModFlags GetMergedKeyModFlags();
2488
2489 // Drag and Drop
2490 IMGUI_API bool BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
2491 IMGUI_API void ClearDragDrop();
2492 IMGUI_API bool IsDragDropPayloadBeingAccepted();
2493
2494 // Internal Columns API (this is not exposed because we will encourage transitioning to the Tables API)
2495 IMGUI_API void SetWindowClipRectBeforeSetChannel(ImGuiWindow* window, const ImRect& clip_rect);
2496 IMGUI_API void BeginColumns(const char* str_id, int count, ImGuiOldColumnFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
2497 IMGUI_API void EndColumns(); // close columns
2498 IMGUI_API void PushColumnClipRect(int column_index);
2499 IMGUI_API void PushColumnsBackground();
2500 IMGUI_API void PopColumnsBackground();
2501 IMGUI_API ImGuiID GetColumnsID(const char* str_id, int count);
2502 IMGUI_API ImGuiOldColumns* FindOrCreateColumns(ImGuiWindow* window, ImGuiID id);
2503 IMGUI_API float GetColumnOffsetFromNorm(const ImGuiOldColumns* columns, float offset_norm);
2504 IMGUI_API float GetColumnNormFromOffset(const ImGuiOldColumns* columns, float offset);
2505
2506 // Tables: Candidates for public API
2507 IMGUI_API void TableOpenContextMenu(int column_n = -1);
2508 IMGUI_API void TableSetColumnWidth(int column_n, float width);
2509 IMGUI_API void TableSetColumnSortDirection(int column_n, ImGuiSortDirection sort_direction, bool append_to_sort_specs);
2510 IMGUI_API int TableGetHoveredColumn(); // May use (TableGetColumnFlags() & ImGuiTableColumnFlags_IsHovered) instead. Return hovered column. return -1 when table is not hovered. return columns_count if the unused space at the right of visible columns is hovered.
2511 IMGUI_API float TableGetHeaderRowHeight();
2512 IMGUI_API void TablePushBackgroundChannel();
2513 IMGUI_API void TablePopBackgroundChannel();
2514
2515 // Tables: Internals
2516 inline ImGuiTable* GetCurrentTable() { ImGuiContext& g = *GImGui; return g.CurrentTable; }
2517 IMGUI_API ImGuiTable* TableFindByID(ImGuiID id);
2518 IMGUI_API bool BeginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags = 0, const ImVec2& outer_size = ImVec2(0, 0), float inner_width = 0.0f);
2519 IMGUI_API void TableBeginInitMemory(ImGuiTable* table, int columns_count);
2520 IMGUI_API void TableBeginApplyRequests(ImGuiTable* table);
2521 IMGUI_API void TableSetupDrawChannels(ImGuiTable* table);
2522 IMGUI_API void TableUpdateLayout(ImGuiTable* table);
2523 IMGUI_API void TableUpdateBorders(ImGuiTable* table);
2524 IMGUI_API void TableUpdateColumnsWeightFromWidth(ImGuiTable* table);
2525 IMGUI_API void TableDrawBorders(ImGuiTable* table);
2526 IMGUI_API void TableDrawContextMenu(ImGuiTable* table);
2527 IMGUI_API void TableMergeDrawChannels(ImGuiTable* table);
2528 IMGUI_API void TableSortSpecsSanitize(ImGuiTable* table);
2529 IMGUI_API void TableSortSpecsBuild(ImGuiTable* table);
2530 IMGUI_API ImGuiSortDirection TableGetColumnNextSortDirection(ImGuiTableColumn* column);
2531 IMGUI_API void TableFixColumnSortDirection(ImGuiTable* table, ImGuiTableColumn* column);
2532 IMGUI_API float TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column);
2533 IMGUI_API void TableBeginRow(ImGuiTable* table);
2534 IMGUI_API void TableEndRow(ImGuiTable* table);
2535 IMGUI_API void TableBeginCell(ImGuiTable* table, int column_n);
2536 IMGUI_API void TableEndCell(ImGuiTable* table);
2537 IMGUI_API ImRect TableGetCellBgRect(const ImGuiTable* table, int column_n);
2538 IMGUI_API const char* TableGetColumnName(const ImGuiTable* table, int column_n);
2539 IMGUI_API ImGuiID TableGetColumnResizeID(const ImGuiTable* table, int column_n, int instance_no = 0);
2540 IMGUI_API float TableGetMaxColumnWidth(const ImGuiTable* table, int column_n);
2541 IMGUI_API void TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n);
2542 IMGUI_API void TableSetColumnWidthAutoAll(ImGuiTable* table);
2543 IMGUI_API void TableRemove(ImGuiTable* table);
2544 IMGUI_API void TableGcCompactTransientBuffers(ImGuiTable* table);
2545 IMGUI_API void TableGcCompactTransientBuffers(ImGuiTableTempData* table);
2546 IMGUI_API void TableGcCompactSettings();
2547
2548 // Tables: Settings
2549 IMGUI_API void TableLoadSettings(ImGuiTable* table);
2550 IMGUI_API void TableSaveSettings(ImGuiTable* table);
2551 IMGUI_API void TableResetSettings(ImGuiTable* table);
2552 IMGUI_API ImGuiTableSettings* TableGetBoundSettings(ImGuiTable* table);
2553 IMGUI_API void TableSettingsInstallHandler(ImGuiContext* context);
2554 IMGUI_API ImGuiTableSettings* TableSettingsCreate(ImGuiID id, int columns_count);
2555 IMGUI_API ImGuiTableSettings* TableSettingsFindByID(ImGuiID id);
2556
2557 // Tab Bars
2558 IMGUI_API bool BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& bb, ImGuiTabBarFlags flags);
2559 IMGUI_API ImGuiTabItem* TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id);
2560 IMGUI_API void TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id);
2561 IMGUI_API void TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
2562 IMGUI_API void TabBarQueueReorder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int offset);
2563 IMGUI_API void TabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, ImVec2 mouse_pos);
2564 IMGUI_API bool TabBarProcessReorder(ImGuiTabBar* tab_bar);
2565 IMGUI_API bool TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags);
2566 IMGUI_API ImVec2 TabItemCalcSize(const char* label, bool has_close_button);
2567 IMGUI_API void TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col);
2568 IMGUI_API void TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible, bool* out_just_closed, bool* out_text_clipped);
2569
2570 // Render helpers
2571 // AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
2572 // NB: All position are in absolute pixels coordinates (we are never using window coordinates internally)
2573 IMGUI_API void RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
2574 IMGUI_API void RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
2575 IMGUI_API void RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
2576 IMGUI_API void RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
2577 IMGUI_API void RenderTextEllipsis(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, float clip_max_x, float ellipsis_max_x, const char* text, const char* text_end, const ImVec2* text_size_if_known);
2578 IMGUI_API void RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
2579 IMGUI_API void RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
2580 IMGUI_API void RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, ImDrawFlags flags = 0);
2581 IMGUI_API void RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_TypeDefault); // Navigation highlight
2582 IMGUI_API const char* FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
2583
2584 // Render helpers (those functions don't access any ImGui state!)
2585 IMGUI_API void RenderArrow(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir, float scale = 1.0f);
2586 IMGUI_API void RenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col);
2587 IMGUI_API void RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz);
2588 IMGUI_API void RenderMouseCursor(ImDrawList* draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow);
2589 IMGUI_API void RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col);
2590 IMGUI_API void RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
2591 IMGUI_API void RenderRectFilledWithHole(ImDrawList* draw_list, ImRect outer, ImRect inner, ImU32 col, float rounding);
2592
2593#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
2594 // [1.71: 2019/06/07: Updating prototypes of some of the internal functions. Leaving those for reference for a short while]
2595 inline void RenderArrow(ImVec2 pos, ImGuiDir dir, float scale=1.0f) { ImGuiWindow* window = GetCurrentWindow(); RenderArrow(window->DrawList, pos, GetColorU32(ImGuiCol_Text), dir, scale); }
2596 inline void RenderBullet(ImVec2 pos) { ImGuiWindow* window = GetCurrentWindow(); RenderBullet(window->DrawList, pos, GetColorU32(ImGuiCol_Text)); }
2597#endif
2598
2599 // Widgets
2600 IMGUI_API void TextEx(const char* text, const char* text_end = NULL, ImGuiTextFlags flags = 0);
2601 IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
2602 IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos);
2603 IMGUI_API bool CollapseButton(ImGuiID id, const ImVec2& pos);
2604 IMGUI_API bool ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags = 0);
2605 IMGUI_API void Scrollbar(ImGuiAxis axis);
2606 IMGUI_API bool ScrollbarEx(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* p_scroll_v, float avail_v, float contents_v, ImDrawFlags flags);
2607 IMGUI_API bool ImageButtonEx(ImGuiID id, ImTextureID texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, const ImVec2& padding, const ImVec4& bg_col, const ImVec4& tint_col);
2608 IMGUI_API ImRect GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis);
2609 IMGUI_API ImGuiID GetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis);
2610 IMGUI_API ImGuiID GetWindowResizeCornerID(ImGuiWindow* window, int n); // 0..3: corners
2611 IMGUI_API ImGuiID GetWindowResizeBorderID(ImGuiWindow* window, ImGuiDir dir);
2612 IMGUI_API void SeparatorEx(ImGuiSeparatorFlags flags);
2613 IMGUI_API bool CheckboxFlags(const char* label, ImS64* flags, ImS64 flags_value);
2614 IMGUI_API bool CheckboxFlags(const char* label, ImU64* flags, ImU64 flags_value);
2615
2616 // Widgets low-level behaviors
2617 IMGUI_API bool ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
2618 IMGUI_API bool DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags);
2619 IMGUI_API bool SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb);
2620 IMGUI_API bool SplitterBehavior(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f, float hover_visibility_delay = 0.0f);
2621 IMGUI_API bool TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
2622 IMGUI_API bool TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0); // Consume previous SetNextItemOpen() data, if any. May return true when logging
2623 IMGUI_API void TreePushOverrideID(ImGuiID id);
2624
2625 // Template functions are instantiated in imgui_widgets.cpp for a finite number of types.
2626 // To use them externally (for custom widget) you may need an "extern template" statement in your code in order to link to existing instances and silence Clang warnings (see #2036).
2627 // e.g. " extern template IMGUI_API float RoundScalarWithFormatT<float, float>(const char* format, ImGuiDataType data_type, float v); "
2628 template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API float ScaleRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_size);
2629 template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API T ScaleValueFromRatioT(ImGuiDataType data_type, float t, T v_min, T v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_size);
2630 template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, T v_min, T v_max, const char* format, ImGuiSliderFlags flags);
2631 template<typename T, typename SIGNED_T, typename FLOAT_T> IMGUI_API bool SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, T v_min, T v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb);
2632 template<typename T, typename SIGNED_T> IMGUI_API T RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, T v);
2633 template<typename T> IMGUI_API bool CheckboxFlagsT(const char* label, T* flags, T flags_value);
2634
2635 // Data type helpers
2636 IMGUI_API const ImGuiDataTypeInfo* DataTypeGetInfo(ImGuiDataType data_type);
2637 IMGUI_API int DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format);
2638 IMGUI_API void DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg_1, const void* arg_2);
2639 IMGUI_API bool DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* p_data, const char* format);
2640 IMGUI_API int DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2);
2641 IMGUI_API bool DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max);
2642
2643 // InputText
2644 IMGUI_API bool InputTextEx(const char* label, const char* hint, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
2645 IMGUI_API bool TempInputText(const ImRect& bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags);
2646 IMGUI_API bool TempInputScalar(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min = NULL, const void* p_clamp_max = NULL);
2647 inline bool TempInputIsActive(ImGuiID id) { ImGuiContext& g = *GImGui; return (g.ActiveId == id && g.TempInputId == id); }
2648 inline ImGuiInputTextState* GetInputTextState(ImGuiID id) { ImGuiContext& g = *GImGui; return (g.InputTextState.ID == id) ? &g.InputTextState : NULL; } // Get input text state if active
2649
2650 // Color
2651 IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
2652 IMGUI_API void ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
2653 IMGUI_API void ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags);
2654
2655 // Plot
2656 IMGUI_API int PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size);
2657
2658 // Shade functions (write over already created vertices)
2659 IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
2660 IMGUI_API void ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
2661
2662 // Garbage collection
2663 IMGUI_API void GcCompactTransientMiscBuffers();
2664 IMGUI_API void GcCompactTransientWindowBuffers(ImGuiWindow* window);
2665 IMGUI_API void GcAwakeTransientWindowBuffers(ImGuiWindow* window);
2666
2667 // Debug Tools
2668 IMGUI_API void ErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback, void* user_data = NULL);
2669 inline void DebugDrawItemRect(ImU32 col = IM_COL32(255,0,0,255)) { ImGuiContext& g = *GImGui; ImGuiWindow* window = g.CurrentWindow; GetForegroundDrawList(window)->AddRect(g.LastItemData.Rect.Min, g.LastItemData.Rect.Max, col); }
2670 inline void DebugStartItemPicker() { ImGuiContext& g = *GImGui; g.DebugItemPickerActive = true; }
2671
2672 IMGUI_API void ShowFontAtlas(ImFontAtlas* atlas);
2673 IMGUI_API void DebugNodeColumns(ImGuiOldColumns* columns);
2674 IMGUI_API void DebugNodeDrawList(ImGuiWindow* window, const ImDrawList* draw_list, const char* label);
2675 IMGUI_API void DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawList* out_draw_list, const ImDrawList* draw_list, const ImDrawCmd* draw_cmd, bool show_mesh, bool show_aabb);
2676 IMGUI_API void DebugNodeFont(ImFont* font);
2677 IMGUI_API void DebugNodeStorage(ImGuiStorage* storage, const char* label);
2678 IMGUI_API void DebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label);
2679 IMGUI_API void DebugNodeTable(ImGuiTable* table);
2680 IMGUI_API void DebugNodeTableSettings(ImGuiTableSettings* settings);
2681 IMGUI_API void DebugNodeWindow(ImGuiWindow* window, const char* label);
2682 IMGUI_API void DebugNodeWindowSettings(ImGuiWindowSettings* settings);
2683 IMGUI_API void DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label);
2684 IMGUI_API void DebugNodeViewport(ImGuiViewportP* viewport);
2685 IMGUI_API void DebugRenderViewportThumbnail(ImDrawList* draw_list, ImGuiViewportP* viewport, const ImRect& bb);
2686
2687} // namespace ImGui
2688
2689
2690//-----------------------------------------------------------------------------
2691// [SECTION] ImFontAtlas internal API
2692//-----------------------------------------------------------------------------
2693
2694// This structure is likely to evolve as we add support for incremental atlas updates
2695struct ImFontBuilderIO
2696{
2697 bool (*FontBuilder_Build)(ImFontAtlas* atlas);
2698};
2699
2700// Helper for font builder
2701IMGUI_API const ImFontBuilderIO* ImFontAtlasGetBuilderForStbTruetype();
2702IMGUI_API void ImFontAtlasBuildInit(ImFontAtlas* atlas);
2703IMGUI_API void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent);
2704IMGUI_API void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* stbrp_context_opaque);
2705IMGUI_API void ImFontAtlasBuildFinish(ImFontAtlas* atlas);
2706IMGUI_API void ImFontAtlasBuildRender8bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned char in_marker_pixel_value);
2707IMGUI_API void ImFontAtlasBuildRender32bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned int in_marker_pixel_value);
2708IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor);
2709IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride);
2710
2711//-----------------------------------------------------------------------------
2712// [SECTION] Test Engine specific hooks (imgui_test_engine)
2713//-----------------------------------------------------------------------------
2714
2715#ifdef IMGUI_ENABLE_TEST_ENGINE
2716extern void ImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, const ImRect& bb, ImGuiID id);
2717extern void ImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags);
2718extern void ImGuiTestEngineHook_IdInfo(ImGuiContext* ctx, ImGuiDataType data_type, ImGuiID id, const void* data_id);
2719extern void ImGuiTestEngineHook_IdInfo(ImGuiContext* ctx, ImGuiDataType data_type, ImGuiID id, const void* data_id, const void* data_id_end);
2720extern void ImGuiTestEngineHook_Log(ImGuiContext* ctx, const char* fmt, ...);
2721#define IMGUI_TEST_ENGINE_ITEM_ADD(_BB,_ID) if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemAdd(&g, _BB, _ID) // Register item bounding box
2722#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS) if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS) // Register item label and status flags (optional)
2723#define IMGUI_TEST_ENGINE_LOG(_FMT,...) if (g.TestEngineHookItems) ImGuiTestEngineHook_Log(&g, _FMT, __VA_ARGS__) // Custom log entry from user land into test log
2724#define IMGUI_TEST_ENGINE_ID_INFO(_ID,_TYPE,_DATA) if (g.TestEngineHookIdInfo == _ID) ImGuiTestEngineHook_IdInfo(&g, _TYPE, _ID, (const void*)(_DATA));
2725#define IMGUI_TEST_ENGINE_ID_INFO2(_ID,_TYPE,_DATA,_DATA2) if (g.TestEngineHookIdInfo == _ID) ImGuiTestEngineHook_IdInfo(&g, _TYPE, _ID, (const void*)(_DATA), (const void*)(_DATA2));
2726#else
2727#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS) ((void)0)
2728#endif
2729
2730//-----------------------------------------------------------------------------
2731
2732#if defined(__clang__)
2733#pragma clang diagnostic pop
2734#elif defined(__GNUC__)
2735#pragma GCC diagnostic pop
2736#endif
2737
2738#ifdef _MSC_VER
2739#pragma warning (pop)
2740#endif
2741
2742#endif // #ifndef IMGUI_DISABLE
2743