vsgImGui: include/vsgImGui/imgui_internal.h Source File

vsgImGui 0.5.0 VulkanSceneGraph, ImGui and ImPlot integration library

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