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> 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 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' 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 #pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion" // warning: bitwise operation between different enumeration types ('XXXFlags_' and 'XXXFlagsPrivate_') is deprecated 101 #if defined(IMGUI_DEFINE_MATH_OPERATORS) && !defined(IMGUI_DEFINE_MATH_OPERATORS_IMPLEMENTED) 102 #error Please '#define IMGUI_DEFINE_MATH_OPERATORS' _BEFORE_ including imgui.h! 106 #ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS // Renamed in 1.74 107 #error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS 109 #ifdef IMGUI_DISABLE_MATH_FUNCTIONS // Renamed in 1.74 110 #error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS 115 #ifndef IMGUI_ENABLE_FREETYPE 116 #define IMGUI_ENABLE_STB_TRUETYPE 133 struct ImGuiDockRequest;
135 struct ImGuiDockNodeSettings;
138 struct ImGuiInputTextDeactivateData;
161 struct ImGuiTableColumnsSettings;
171 enum ImGuiLocKey : int;
172 typedef int ImGuiDataAuthority;
173 typedef int ImGuiLayoutType;
176 typedef int ImGuiActivateFlags;
177 typedef int ImGuiDebugLogFlags;
178 typedef int ImGuiFocusRequestFlags;
179 typedef int ImGuiItemFlags;
180 typedef int ImGuiItemStatusFlags;
181 typedef int ImGuiOldColumnFlags;
182 typedef int ImGuiNavHighlightFlags;
183 typedef int ImGuiNavMoveFlags;
184 typedef int ImGuiNextItemDataFlags;
185 typedef int ImGuiNextWindowDataFlags;
186 typedef int ImGuiScrollFlags;
187 typedef int ImGuiSeparatorFlags;
188 typedef int ImGuiTextFlags;
189 typedef int ImGuiTooltipFlags;
190 typedef int ImGuiTypingSelectFlags;
191 typedef int ImGuiWindowRefreshFlags;
193 typedef void (*ImGuiErrorLogCallback)(
void* user_data,
const char* fmt, ...);
211 #undef IMSTB_TEXTEDIT_STRING 212 #undef IMSTB_TEXTEDIT_CHARTYPE 213 #define IMSTB_TEXTEDIT_STRING ImGuiInputTextState 214 #define IMSTB_TEXTEDIT_CHARTYPE ImWchar 215 #define IMSTB_TEXTEDIT_GETWIDTH_NEWLINE (-1.0f) 216 #define IMSTB_TEXTEDIT_UNDOSTATECOUNT 99 217 #define IMSTB_TEXTEDIT_UNDOCHARCOUNT 999 218 #include "imstb_textedit.h" 227 #define IMGUI_PAYLOAD_TYPE_WINDOW "_IMWINDOW" // Payload == ImGuiWindow* 231 #ifndef IMGUI_DEBUG_PRINTF 232 #ifndef IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS 233 #define IMGUI_DEBUG_PRINTF(_FMT,...) printf(_FMT, __VA_ARGS__) 235 #define IMGUI_DEBUG_PRINTF(_FMT,...) ((void)0) 240 #ifndef IMGUI_DISABLE_DEBUG_TOOLS 241 #define IMGUI_DEBUG_LOG(...) ImGui::DebugLog(__VA_ARGS__) 243 #define IMGUI_DEBUG_LOG(...) ((void)0) 245 #define IMGUI_DEBUG_LOG_ACTIVEID(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 246 #define IMGUI_DEBUG_LOG_FOCUS(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 247 #define IMGUI_DEBUG_LOG_POPUP(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 248 #define IMGUI_DEBUG_LOG_NAV(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 249 #define IMGUI_DEBUG_LOG_SELECTION(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 250 #define IMGUI_DEBUG_LOG_CLIPPER(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 251 #define IMGUI_DEBUG_LOG_IO(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 252 #define IMGUI_DEBUG_LOG_INPUTROUTING(...) do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 253 #define IMGUI_DEBUG_LOG_DOCKING(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 254 #define IMGUI_DEBUG_LOG_VIEWPORT(...) do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0) 257 #define IM_STATIC_ASSERT(_COND) static_assert(_COND, "") 262 #ifdef IMGUI_DEBUG_PARANOID 263 #define IM_ASSERT_PARANOID(_EXPR) IM_ASSERT(_EXPR) 265 #define IM_ASSERT_PARANOID(_EXPR) 270 #ifndef IM_ASSERT_USER_ERROR 271 #define IM_ASSERT_USER_ERROR(_EXP,_MSG) IM_ASSERT((_EXP) && _MSG) // Recoverable User Error 275 #define IM_PI 3.14159265358979323846f 277 #define IM_NEWLINE "\r\n" // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!) 279 #define IM_NEWLINE "\n" 281 #ifndef IM_TABSIZE // Until we move this to runtime and/or add proper tab support, at least allow users to compile-time override 282 #define IM_TABSIZE (4) 284 #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 285 #define IM_F32_TO_INT8_UNBOUND(_VAL) ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f))) // Unsaturated, for display purpose 286 #define IM_F32_TO_INT8_SAT(_VAL) ((int)(ImSaturate(_VAL) * 255.0f + 0.5f)) // Saturated, always output 0..255 287 #define IM_TRUNC(_VAL) ((float)(int)(_VAL)) // ImTrunc() is not inlined in MSVC debug builds 288 #define IM_ROUND(_VAL) ((float)(int)((_VAL) + 0.5f)) // 289 #define IM_STRINGIFY_HELPER(_X) #_X 290 #define IM_STRINGIFY(_X) IM_STRINGIFY_HELPER(_X) // Preprocessor idiom to stringify e.g. an integer. 291 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS 292 #define IM_FLOOR IM_TRUNC 297 #define IMGUI_CDECL __cdecl 303 #if defined(_MSC_VER) && !defined(__clang__) 304 #define IM_MSVC_WARNING_SUPPRESS(XXXX) __pragma(warning(suppress: XXXX)) 306 #define IM_MSVC_WARNING_SUPPRESS(XXXX) 312 #ifndef IM_DEBUG_BREAK 313 #if defined (_MSC_VER) 314 #define IM_DEBUG_BREAK() __debugbreak() 315 #elif defined(__clang__) 316 #define IM_DEBUG_BREAK() __builtin_debugtrap() 317 #elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) 318 #define IM_DEBUG_BREAK() __asm__ volatile("int3;nop") 319 #elif defined(__GNUC__) && defined(__thumb__) 320 #define IM_DEBUG_BREAK() __asm__ volatile(".inst 0xde01") 321 #elif defined(__GNUC__) && defined(__arm__) && !defined(__thumb__) 322 #define IM_DEBUG_BREAK() __asm__ volatile(".inst 0xe7f001f0") 324 #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! 326 #endif // #ifndef IM_DEBUG_BREAK 330 #if defined(_MSC_VER) && !defined(__clang__) 331 #define IM_PRId64 "I64d" 332 #define IM_PRIu64 "I64u" 333 #define IM_PRIX64 "I64X" 335 #define IM_PRId64 "lld" 336 #define IM_PRIu64 "llu" 337 #define IM_PRIX64 "llX" 366 IMGUI_API ImGuiID ImHashData(
const void* data,
size_t data_size, ImGuiID seed = 0);
367 IMGUI_API ImGuiID ImHashStr(
const char* data,
size_t data_size = 0, ImGuiID seed = 0);
371 static inline void ImQsort(
void* base,
size_t count,
size_t size_of_element,
int(IMGUI_CDECL *compare_func)(
void const*,
void const*)) {
if (count > 1) qsort(base, count, size_of_element, compare_func); }
375 IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);
378 static inline bool ImIsPowerOfTwo(
int v) {
return v != 0 && (v & (v - 1)) == 0; }
379 static inline bool ImIsPowerOfTwo(ImU64 v) {
return v != 0 && (v & (v - 1)) == 0; }
380 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; }
383 IMGUI_API
int ImStricmp(
const char* str1,
const char* str2);
384 IMGUI_API
int ImStrnicmp(
const char* str1,
const char* str2,
size_t count);
385 IMGUI_API
void ImStrncpy(
char* dst,
const char* src,
size_t count);
386 IMGUI_API
char* ImStrdup(
const char* str);
387 IMGUI_API
char* ImStrdupcpy(
char* dst,
size_t* p_dst_size,
const char* str);
388 IMGUI_API
const char* ImStrchrRange(
const char* str_begin,
const char* str_end,
char c);
389 IMGUI_API
const char* ImStreolRange(
const char* str,
const char* str_end);
390 IMGUI_API
const char* ImStristr(
const char* haystack,
const char* haystack_end,
const char* needle,
const char* needle_end);
391 IMGUI_API
void ImStrTrimBlanks(
char* str);
392 IMGUI_API
const char* ImStrSkipBlank(
const char* str);
393 IMGUI_API
int ImStrlenW(
const ImWchar* str);
394 IMGUI_API
const ImWchar*ImStrbolW(
const ImWchar* buf_mid_line,
const ImWchar* buf_begin);
395 IM_MSVC_RUNTIME_CHECKS_OFF
396 static inline char ImToUpper(
char c) {
return (c >=
'a' && c <=
'z') ? c &= ~32 : c; }
397 static inline bool ImCharIsBlankA(
char c) {
return c ==
' ' || c ==
'\t'; }
398 static inline bool ImCharIsBlankW(
unsigned int c) {
return c ==
' ' || c ==
'\t' || c == 0x3000; }
399 IM_MSVC_RUNTIME_CHECKS_RESTORE
402 IMGUI_API
int ImFormatString(
char* buf,
size_t buf_size,
const char* fmt, ...) IM_FMTARGS(3);
403 IMGUI_API
int ImFormatStringV(
char* buf,
size_t buf_size,
const char* fmt, va_list args) IM_FMTLIST(3);
404 IMGUI_API
void ImFormatStringToTempBuffer(
const char** out_buf,
const char** out_buf_end,
const char* fmt, ...) IM_FMTARGS(3);
405 IMGUI_API
void ImFormatStringToTempBufferV(
const char** out_buf,
const char** out_buf_end,
const char* fmt, va_list args) IM_FMTLIST(3);
406 IMGUI_API
const char* ImParseFormatFindStart(
const char* format);
407 IMGUI_API
const char* ImParseFormatFindEnd(
const char* format);
408 IMGUI_API
const char* ImParseFormatTrimDecorations(
const char* format,
char* buf,
size_t buf_size);
409 IMGUI_API
void ImParseFormatSanitizeForPrinting(
const char* fmt_in,
char* fmt_out,
size_t fmt_out_size);
410 IMGUI_API
const char* ImParseFormatSanitizeForScanning(
const char* fmt_in,
char* fmt_out,
size_t fmt_out_size);
411 IMGUI_API
int ImParseFormatPrecision(
const char* format,
int default_value);
414 IMGUI_API
const char* ImTextCharToUtf8(
char out_buf[5],
unsigned int c);
415 IMGUI_API
int ImTextStrToUtf8(
char* out_buf,
int out_buf_size,
const ImWchar* in_text,
const ImWchar* in_text_end);
416 IMGUI_API
int ImTextCharFromUtf8(
unsigned int* out_char,
const char* in_text,
const char* in_text_end);
417 IMGUI_API
int ImTextStrFromUtf8(ImWchar* out_buf,
int out_buf_size,
const char* in_text,
const char* in_text_end,
const char** in_remaining = NULL);
418 IMGUI_API
int ImTextCountCharsFromUtf8(
const char* in_text,
const char* in_text_end);
419 IMGUI_API
int ImTextCountUtf8BytesFromChar(
const char* in_text,
const char* in_text_end);
420 IMGUI_API
int ImTextCountUtf8BytesFromStr(
const ImWchar* in_text,
const ImWchar* in_text_end);
421 IMGUI_API
const char* ImTextFindPreviousUtf8Codepoint(
const char* in_text_start,
const char* in_text_curr);
422 IMGUI_API
int ImTextCountLines(
const char* in_text,
const char* in_text_end);
425 #ifdef IMGUI_DISABLE_FILE_FUNCTIONS 426 #define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS 427 typedef void* ImFileHandle;
428 static inline ImFileHandle ImFileOpen(
const char*,
const char*) {
return NULL; }
429 static inline bool ImFileClose(ImFileHandle) {
return false; }
430 static inline ImU64 ImFileGetSize(ImFileHandle) {
return (ImU64)-1; }
431 static inline ImU64 ImFileRead(
void*, ImU64, ImU64, ImFileHandle) {
return 0; }
432 static inline ImU64 ImFileWrite(
const void*, ImU64, ImU64, ImFileHandle) {
return 0; }
434 #ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS 435 typedef FILE* ImFileHandle;
436 IMGUI_API ImFileHandle ImFileOpen(
const char* filename,
const char* mode);
437 IMGUI_API
bool ImFileClose(ImFileHandle file);
438 IMGUI_API ImU64 ImFileGetSize(ImFileHandle file);
439 IMGUI_API ImU64 ImFileRead(
void* data, ImU64 size, ImU64 count, ImFileHandle file);
440 IMGUI_API ImU64 ImFileWrite(
const void* data, ImU64 size, ImU64 count, ImFileHandle file);
442 #define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions 444 IMGUI_API
void* ImFileLoadToMemory(
const char* filename,
const char* mode,
size_t* out_file_size = NULL,
int padding_bytes = 0);
447 IM_MSVC_RUNTIME_CHECKS_OFF
449 #ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS 450 #define ImFabs(X) fabsf(X) 451 #define ImSqrt(X) sqrtf(X) 452 #define ImFmod(X, Y) fmodf((X), (Y)) 453 #define ImCos(X) cosf(X) 454 #define ImSin(X) sinf(X) 455 #define ImAcos(X) acosf(X) 456 #define ImAtan2(Y, X) atan2f((Y), (X)) 457 #define ImAtof(STR) atof(STR) 458 #define ImCeil(X) ceilf(X) 459 static inline float ImPow(
float x,
float y) {
return powf(x, y); }
460 static inline double ImPow(
double x,
double y) {
return pow(x, y); }
461 static inline float ImLog(
float x) {
return logf(x); }
462 static inline double ImLog(
double x) {
return log(x); }
463 static inline int ImAbs(
int x) {
return x < 0 ? -x : x; }
464 static inline float ImAbs(
float x) {
return fabsf(x); }
465 static inline double ImAbs(
double x) {
return fabs(x); }
466 static inline float ImSign(
float x) {
return (x < 0.0f) ? -1.0f : (x > 0.0f) ? 1.0f : 0.0f; }
467 static inline double ImSign(
double x) {
return (x < 0.0) ? -1.0 : (x > 0.0) ? 1.0 : 0.0; }
468 #ifdef IMGUI_ENABLE_SSE 469 static inline float ImRsqrt(
float x) {
return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }
471 static inline float ImRsqrt(
float x) {
return 1.0f / sqrtf(x); }
473 static inline double ImRsqrt(
double x) {
return 1.0 / sqrt(x); }
477 template<
typename T>
static inline T ImMin(T lhs, T rhs) {
return lhs < rhs ? lhs : rhs; }
478 template<
typename T>
static inline T ImMax(T lhs, T rhs) {
return lhs >= rhs ? lhs : rhs; }
479 template<
typename T>
static inline T ImClamp(T v, T mn, T mx) {
return (v < mn) ? mn : (v > mx) ? mx : v; }
480 template<
typename T>
static inline T ImLerp(T a, T b,
float t) {
return (T)(a + (b - a) * t); }
481 template<
typename T>
static inline void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
482 template<
typename T>
static inline T ImAddClampOverflow(T a, T b, T mn, T mx) {
if (b < 0 && (a < mn - b))
return mn;
if (b > 0 && (a > mx - b))
return mx;
return a + b; }
483 template<
typename T>
static inline T ImSubClampOverflow(T a, T b, T mn, T mx) {
if (b > 0 && (a < mn + b))
return mn;
if (b < 0 && (a > mx + b))
return mx;
return a - b; }
485 static inline ImVec2 ImMin(
const ImVec2& lhs,
const ImVec2& rhs) {
return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
486 static inline ImVec2 ImMax(
const ImVec2& lhs,
const ImVec2& rhs) {
return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
487 static inline ImVec2 ImClamp(
const ImVec2& v,
const ImVec2& mn,
ImVec2 mx) {
return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }
488 static inline ImVec2 ImLerp(
const ImVec2& a,
const ImVec2& b,
float t) {
return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
489 static inline ImVec2 ImLerp(
const ImVec2& a,
const ImVec2& b,
const ImVec2& t) {
return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
490 static inline ImVec4 ImLerp(
const ImVec4& a,
const ImVec4& b,
float t) {
return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
491 static inline float ImSaturate(
float f) {
return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
492 static inline float ImLengthSqr(
const ImVec2& lhs) {
return (lhs.x * lhs.x) + (lhs.y * lhs.y); }
493 static inline float ImLengthSqr(
const ImVec4& lhs) {
return (lhs.x * lhs.x) + (lhs.y * lhs.y) + (lhs.z * lhs.z) + (lhs.w * lhs.w); }
494 static inline float ImInvLength(
const ImVec2& lhs,
float fail_value) {
float d = (lhs.x * lhs.x) + (lhs.y * lhs.y);
if (d > 0.0f)
return ImRsqrt(d);
return fail_value; }
495 static inline float ImTrunc(
float f) {
return (
float)(int)(f); }
496 static inline ImVec2 ImTrunc(
const ImVec2& v) {
return ImVec2((
float)(
int)(v.x), (
float)(
int)(v.y)); }
497 static inline float ImFloor(
float f) {
return (
float)((f >= 0 || (float)(
int)f == f) ? (
int)f : (int)f - 1); }
498 static inline ImVec2 ImFloor(
const ImVec2& v) {
return ImVec2(ImFloor(v.x), ImFloor(v.y)); }
499 static inline int ImModPositive(
int a,
int b) {
return (a + b) % b; }
500 static inline float ImDot(
const ImVec2& a,
const ImVec2& b) {
return a.x * b.x + a.y * b.y; }
501 static inline ImVec2 ImRotate(
const ImVec2& v,
float cos_a,
float sin_a) {
return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
502 static 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; }
504 static inline bool ImIsFloatAboveGuaranteedIntegerPrecision(
float f) {
return f <= -16777216 || f >= 16777216; }
505 static inline float ImExponentialMovingAverage(
float avg,
float sample,
int n) { avg -= avg / n; avg += sample / n;
return avg; }
506 IM_MSVC_RUNTIME_CHECKS_RESTORE
516 IMGUI_API
void ImTriangleBarycentricCoords(
const ImVec2& a,
const ImVec2& b,
const ImVec2& c,
const ImVec2& p,
float& out_u,
float& out_v,
float& out_w);
517 inline float ImTriangleArea(
const ImVec2& a,
const ImVec2& b,
const ImVec2& c) {
return ImFabs((a.x * (b.y - c.y)) + (b.x * (c.y - a.y)) + (c.x * (a.y - b.y))) * 0.5f; }
518 inline bool ImTriangleIsClockwise(
const ImVec2& a,
const ImVec2& b,
const ImVec2& c) {
return ((b.x - a.x) * (c.y - b.y)) - ((c.x - b.x) * (b.y - a.y)) > 0.0f; }
522 IM_MSVC_RUNTIME_CHECKS_OFF
526 constexpr
ImVec1() : x(0.0f) { }
527 constexpr ImVec1(
float _x) : x(_x) { }
534 constexpr
ImVec2ih() : x(0), y(0) {}
535 constexpr ImVec2ih(
short _x,
short _y) : x(_x), y(_y) {}
536 constexpr
explicit ImVec2ih(
const ImVec2& rhs) : x((
short)rhs.x), y((
short)rhs.y) {}
546 constexpr
ImRect() : Min(0.0f, 0.0f), Max(0.0f, 0.0f) {}
547 constexpr ImRect(
const ImVec2& min,
const ImVec2& max) : Min(min), Max(max) {}
548 constexpr ImRect(
const ImVec4& v) : Min(v.x, v.y), Max(v.z, v.w) {}
549 constexpr ImRect(
float x1,
float y1,
float x2,
float y2) : Min(x1, y1), Max(x2, y2) {}
551 ImVec2 GetCenter()
const {
return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
552 ImVec2 GetSize()
const {
return ImVec2(Max.x - Min.x, Max.y - Min.y); }
553 float GetWidth()
const {
return Max.x - Min.x; }
554 float GetHeight()
const {
return Max.y - Min.y; }
555 float GetArea()
const {
return (Max.x - Min.x) * (Max.y - Min.y); }
556 ImVec2 GetTL()
const {
return Min; }
559 ImVec2 GetBR()
const {
return Max; }
560 bool Contains(
const ImVec2& p)
const {
return p.x >= Min.x && p.y >= Min.y && p.x < Max.x && p.y < Max.y; }
561 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; }
562 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; }
563 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; }
564 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; }
565 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; }
566 void Expand(
const float amount) { Min.x -= amount; Min.y -= amount; Max.x += amount; Max.y += amount; }
567 void Expand(
const ImVec2& amount) { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
568 void Translate(
const ImVec2& d) { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }
569 void TranslateX(
float dx) { Min.x += dx; Max.x += dx; }
570 void TranslateY(
float dy) { Min.y += dy; Max.y += dy; }
571 void ClipWith(
const ImRect& r) { Min = ImMax(Min, r.Min); Max = ImMin(Max, r.Max); }
572 void ClipWithFull(
const ImRect& r) { Min = ImClamp(Min, r.Min, r.Max); Max = ImClamp(Max, r.Min, r.Max); }
573 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); }
574 bool IsInverted()
const {
return Min.x > Max.x || Min.y > Max.y; }
575 ImVec4 ToVec4()
const {
return ImVec4(Min.x, Min.y, Max.x, Max.y); }
579 #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! 580 #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! 581 inline size_t ImBitArrayGetStorageSizeInBytes(
int bitcount) {
return (
size_t)((bitcount + 31) >> 5) << 2; }
582 inline void ImBitArrayClearAllBits(ImU32* arr,
int bitcount){ memset(arr, 0, ImBitArrayGetStorageSizeInBytes(bitcount)); }
583 inline bool ImBitArrayTestBit(
const ImU32* arr,
int n) { ImU32 mask = (ImU32)1 << (n & 31);
return (arr[n >> 5] & mask) != 0; }
584 inline void ImBitArrayClearBit(ImU32* arr,
int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] &= ~mask; }
585 inline void ImBitArraySetBit(ImU32* arr,
int n) { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] |= mask; }
586 inline void ImBitArraySetBitRange(ImU32* arr,
int n,
int n2)
591 int a_mod = (n & 31);
592 int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
593 ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
599 typedef ImU32* ImBitArrayPtr;
603 template<
int BITCOUNT,
int OFFSET = 0>
606 ImU32 Storage[(BITCOUNT + 31) >> 5];
608 void ClearAllBits() { memset(Storage, 0,
sizeof(Storage)); }
609 void SetAllBits() { memset(Storage, 255,
sizeof(Storage)); }
610 bool TestBit(
int n)
const { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT);
return IM_BITARRAY_TESTBIT(Storage, n); }
611 void SetBit(
int n) { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArraySetBit(Storage, n); }
612 void ClearBit(
int n) { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT); ImBitArrayClearBit(Storage, n); }
613 void SetBitRange(
int n,
int n2) { n += OFFSET; n2 += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT && n2 > n && n2 <= BITCOUNT); ImBitArraySetBitRange(Storage, n, n2); }
614 bool operator[](
int n)
const { n += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT);
return IM_BITARRAY_TESTBIT(Storage, n); }
622 void Create(
int sz) { Storage.resize((sz + 31) >> 5); memset(Storage.Data, 0, (
size_t)Storage.Size *
sizeof(Storage.Data[0])); }
623 void Clear() { Storage.clear(); }
624 bool TestBit(
int n)
const { IM_ASSERT(n < (Storage.Size << 5));
return IM_BITARRAY_TESTBIT(Storage.Data, n); }
625 void SetBit(
int n) { IM_ASSERT(n < (Storage.Size << 5)); ImBitArraySetBit(Storage.Data, n); }
626 void ClearBit(
int n) { IM_ASSERT(n < (Storage.Size << 5)); ImBitArrayClearBit(Storage.Data, n); }
628 IM_MSVC_RUNTIME_CHECKS_RESTORE
639 inline ImSpan() { Data = DataEnd = NULL; }
640 inline ImSpan(T* data,
int size) { Data = data; DataEnd = data + size; }
641 inline ImSpan(T* data, T* data_end) { Data = data; DataEnd = data_end; }
643 inline void set(T* data,
int size) { Data = data; DataEnd = data + size; }
644 inline void set(T* data, T* data_end) { Data = data; DataEnd = data_end; }
645 inline int size()
const {
return (
int)(ptrdiff_t)(DataEnd - Data); }
646 inline int size_in_bytes()
const {
return (
int)(ptrdiff_t)(DataEnd - Data) * (int)
sizeof(T); }
647 inline T& operator[](
int i) { T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd);
return *p; }
648 inline const T& operator[](
int i)
const {
const T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd);
return *p; }
650 inline T* begin() {
return Data; }
651 inline const T* begin()
const {
return Data; }
652 inline T* end() {
return DataEnd; }
653 inline const T* end()
const {
return DataEnd; }
656 inline int index_from_ptr(
const T* it)
const { IM_ASSERT(it >= Data && it < DataEnd);
const ptrdiff_t off = it - Data;
return (
int)off; }
672 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; }
673 inline int GetArenaSizeInBytes() {
return CurrOff; }
674 inline void SetArenaBasePtr(
void* base_ptr) { BasePtr = (
char*)base_ptr; }
675 inline void* GetSpanPtrBegin(
int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS);
return (
void*)(BasePtr + Offsets[n]); }
676 inline void* GetSpanPtrEnd(
int n) { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS);
return (
void*)(BasePtr + Offsets[n] + Sizes[n]); }
678 inline void GetSpan(
int n,
ImSpan<T>* span) { span->set((T*)GetSpanPtrBegin(n), (T*)GetSpanPtrEnd(n)); }
684 typedef int ImPoolIdx;
691 ImPoolIdx AliveCount;
693 ImPool() { FreeIdx = AliveCount = 0; }
695 T* GetByKey(ImGuiID key) {
int idx = Map.GetInt(key, -1);
return (idx != -1) ? &Buf[idx] : NULL; }
696 T* GetByIndex(ImPoolIdx n) {
return &Buf[n]; }
697 ImPoolIdx GetIndex(
const T* p)
const { IM_ASSERT(p >= Buf.Data && p < Buf.Data + Buf.Size);
return (ImPoolIdx)(p - Buf.Data); }
698 T* GetOrAddByKey(ImGuiID key) {
int* p_idx = Map.GetIntRef(key, -1);
if (*p_idx != -1)
return &Buf[*p_idx]; *p_idx = FreeIdx;
return Add(); }
699 bool Contains(
const T* p)
const {
return (p >= Buf.Data && p < Buf.Data + Buf.Size); }
700 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; }
701 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]; }
702 void Remove(ImGuiID key,
const T* p) { Remove(key, GetIndex(p)); }
703 void Remove(ImGuiID key, ImPoolIdx idx) { Buf[idx].~T(); *(
int*)&Buf[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); AliveCount--; }
704 void Reserve(
int capacity) { Buf.reserve(capacity); Map.Data.reserve(capacity); }
708 int GetAliveCount()
const {
return AliveCount; }
709 int GetBufSize()
const {
return Buf.Size; }
710 int GetMapSize()
const {
return Map.Data.Size; }
711 T* TryGetMapData(ImPoolIdx n) {
int idx = Map.Data[n].val_i;
if (idx == -1)
return NULL;
return GetByIndex(idx); }
724 void clear() { Buf.clear(); }
725 bool empty()
const {
return Buf.Size == 0; }
726 int size()
const {
return Buf.Size; }
727 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); }
728 T* begin() {
size_t HDR_SZ = 4;
if (!Buf.Data)
return NULL;
return (T*)(
void*)(Buf.Data + HDR_SZ); }
729 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; }
730 int chunk_size(
const T* p) {
return ((
const int*)p)[-1]; }
731 T* end() {
return (T*)(
void*)(Buf.Data + Buf.Size); }
732 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; }
733 T* ptr_from_offset(
int off) { IM_ASSERT(off >= 4 && off < Buf.Size);
return (T*)(
void*)(Buf.Data + off); }
744 void clear() { LineOffsets.clear(); EndOffset = 0; }
745 int size() {
return LineOffsets.Size; }
746 const char* get_line_begin(
const char* base,
int n) {
return base + LineOffsets[n]; }
747 const char* get_line_end(
const char* base,
int n) {
return base + (n + 1 < LineOffsets.Size ? (LineOffsets[n + 1] - 1) : EndOffset); }
748 void append(
const char* base,
int old_size,
int new_size);
765 #define IM_ROUNDUP_TO_EVEN(_V) ((((_V) + 1) / 2) * 2) 766 #define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN 4 767 #define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX 512 768 #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) 771 #define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR) ((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI)))) 772 #define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD) ((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD)) 775 #ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE 776 #define IM_DRAWLIST_ARCFAST_TABLE_SIZE 48 // Number of samples in lookup table. 778 #define IM_DRAWLIST_ARCFAST_SAMPLE_MAX IM_DRAWLIST_ARCFAST_TABLE_SIZE // Sample index _PathArcToFastEx() for 360 angle. 787 float CurveTessellationTol;
788 float CircleSegmentMaxError;
789 ImVec4 ClipRectFullscreen;
790 ImDrawListFlags InitialFlags;
796 ImVec2 ArcFastVtx[IM_DRAWLIST_ARCFAST_TABLE_SIZE];
797 float ArcFastRadiusCutoff;
798 ImU8 CircleSegmentCounts[64];
802 void SetCircleTessellationMaxError(
float max_error);
825 ImGuiItemFlags_None = 0,
826 ImGuiItemFlags_NoTabStop = 1 << 0,
827 ImGuiItemFlags_ButtonRepeat = 1 << 1,
828 ImGuiItemFlags_Disabled = 1 << 2,
829 ImGuiItemFlags_NoNav = 1 << 3,
830 ImGuiItemFlags_NoNavDefaultFocus = 1 << 4,
831 ImGuiItemFlags_SelectableDontClosePopup = 1 << 5,
832 ImGuiItemFlags_MixedValue = 1 << 6,
833 ImGuiItemFlags_ReadOnly = 1 << 7,
834 ImGuiItemFlags_NoWindowHoverableCheck = 1 << 8,
835 ImGuiItemFlags_AllowOverlap = 1 << 9,
838 ImGuiItemFlags_Inputable = 1 << 10,
839 ImGuiItemFlags_HasSelectionUserData = 1 << 11,
844 enum ImGuiItemStatusFlags_
846 ImGuiItemStatusFlags_None = 0,
847 ImGuiItemStatusFlags_HoveredRect = 1 << 0,
848 ImGuiItemStatusFlags_HasDisplayRect = 1 << 1,
849 ImGuiItemStatusFlags_Edited = 1 << 2,
850 ImGuiItemStatusFlags_ToggledSelection = 1 << 3,
851 ImGuiItemStatusFlags_ToggledOpen = 1 << 4,
852 ImGuiItemStatusFlags_HasDeactivated = 1 << 5,
853 ImGuiItemStatusFlags_Deactivated = 1 << 6,
854 ImGuiItemStatusFlags_HoveredWindow = 1 << 7,
855 ImGuiItemStatusFlags_Visible = 1 << 8,
856 ImGuiItemStatusFlags_HasClipRect = 1 << 9,
857 ImGuiItemStatusFlags_HasShortcut = 1 << 10,
860 #ifdef IMGUI_ENABLE_TEST_ENGINE 861 ImGuiItemStatusFlags_Openable = 1 << 20,
862 ImGuiItemStatusFlags_Opened = 1 << 21,
863 ImGuiItemStatusFlags_Checkable = 1 << 22,
864 ImGuiItemStatusFlags_Checked = 1 << 23,
865 ImGuiItemStatusFlags_Inputable = 1 << 24,
870 enum ImGuiHoveredFlagsPrivate_
872 ImGuiHoveredFlags_DelayMask_ = ImGuiHoveredFlags_DelayNone | ImGuiHoveredFlags_DelayShort | ImGuiHoveredFlags_DelayNormal | ImGuiHoveredFlags_NoSharedDelay,
873 ImGuiHoveredFlags_AllowedMaskForIsWindowHovered = ImGuiHoveredFlags_ChildWindows | ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_AnyWindow | ImGuiHoveredFlags_NoPopupHierarchy | ImGuiHoveredFlags_DockHierarchy | ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary,
874 ImGuiHoveredFlags_AllowedMaskForIsItemHovered = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled | ImGuiHoveredFlags_NoNavOverride | ImGuiHoveredFlags_ForTooltip | ImGuiHoveredFlags_Stationary | ImGuiHoveredFlags_DelayMask_,
878 enum ImGuiInputTextFlagsPrivate_
881 ImGuiInputTextFlags_Multiline = 1 << 26,
882 ImGuiInputTextFlags_NoMarkEdited = 1 << 27,
883 ImGuiInputTextFlags_MergedItem = 1 << 28,
884 ImGuiInputTextFlags_LocalizeDecimalPoint= 1 << 29,
888 enum ImGuiButtonFlagsPrivate_
890 ImGuiButtonFlags_PressedOnClick = 1 << 4,
891 ImGuiButtonFlags_PressedOnClickRelease = 1 << 5,
892 ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 1 << 6,
893 ImGuiButtonFlags_PressedOnRelease = 1 << 7,
894 ImGuiButtonFlags_PressedOnDoubleClick = 1 << 8,
895 ImGuiButtonFlags_PressedOnDragDropHold = 1 << 9,
896 ImGuiButtonFlags_Repeat = 1 << 10,
897 ImGuiButtonFlags_FlattenChildren = 1 << 11,
898 ImGuiButtonFlags_AllowOverlap = 1 << 12,
899 ImGuiButtonFlags_DontClosePopups = 1 << 13,
901 ImGuiButtonFlags_AlignTextBaseLine = 1 << 15,
902 ImGuiButtonFlags_NoKeyModifiers = 1 << 16,
903 ImGuiButtonFlags_NoHoldingActiveId = 1 << 17,
904 ImGuiButtonFlags_NoNavFocus = 1 << 18,
905 ImGuiButtonFlags_NoHoveredOnFocus = 1 << 19,
906 ImGuiButtonFlags_NoSetKeyOwner = 1 << 20,
907 ImGuiButtonFlags_NoTestKeyOwner = 1 << 21,
908 ImGuiButtonFlags_PressedOnMask_ = ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold,
909 ImGuiButtonFlags_PressedOnDefault_ = ImGuiButtonFlags_PressedOnClickRelease,
913 enum ImGuiComboFlagsPrivate_
915 ImGuiComboFlags_CustomPreview = 1 << 20,
919 enum ImGuiSliderFlagsPrivate_
921 ImGuiSliderFlags_Vertical = 1 << 20,
922 ImGuiSliderFlags_ReadOnly = 1 << 21,
926 enum ImGuiSelectableFlagsPrivate_
929 ImGuiSelectableFlags_NoHoldingActiveID = 1 << 20,
930 ImGuiSelectableFlags_SelectOnNav = 1 << 21,
931 ImGuiSelectableFlags_SelectOnClick = 1 << 22,
932 ImGuiSelectableFlags_SelectOnRelease = 1 << 23,
933 ImGuiSelectableFlags_SpanAvailWidth = 1 << 24,
934 ImGuiSelectableFlags_SetNavIdOnHover = 1 << 25,
935 ImGuiSelectableFlags_NoPadWithHalfSpacing = 1 << 26,
936 ImGuiSelectableFlags_NoSetKeyOwner = 1 << 27,
940 enum ImGuiTreeNodeFlagsPrivate_
942 ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1 << 20,
943 ImGuiTreeNodeFlags_UpsideDownArrow = 1 << 21,
946 enum ImGuiSeparatorFlags_
948 ImGuiSeparatorFlags_None = 0,
949 ImGuiSeparatorFlags_Horizontal = 1 << 0,
950 ImGuiSeparatorFlags_Vertical = 1 << 1,
951 ImGuiSeparatorFlags_SpanAllColumns = 1 << 2,
957 enum ImGuiFocusRequestFlags_
959 ImGuiFocusRequestFlags_None = 0,
960 ImGuiFocusRequestFlags_RestoreFocusedChild = 1 << 0,
961 ImGuiFocusRequestFlags_UnlessBelowModal = 1 << 1,
966 ImGuiTextFlags_None = 0,
967 ImGuiTextFlags_NoWidthForLargeClippedText = 1 << 0,
970 enum ImGuiTooltipFlags_
972 ImGuiTooltipFlags_None = 0,
973 ImGuiTooltipFlags_OverridePrevious = 1 << 1,
978 enum ImGuiLayoutType_
980 ImGuiLayoutType_Horizontal = 0,
981 ImGuiLayoutType_Vertical = 1
986 ImGuiLogType_None = 0,
990 ImGuiLogType_Clipboard,
1003 ImGuiPlotType_Lines,
1004 ImGuiPlotType_Histogram,
1017 ImGuiStyleVar VarIdx;
1018 union {
int BackupInt[2];
float BackupFloat[2]; };
1019 ImGuiStyleMod(ImGuiStyleVar idx,
int v) { VarIdx = idx; BackupInt[0] = v; }
1020 ImGuiStyleMod(ImGuiStyleVar idx,
float v) { VarIdx = idx; BackupFloat[0] = v; }
1021 ImGuiStyleMod(ImGuiStyleVar idx,
ImVec2 v) { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }
1029 ImVec2 BackupCursorMaxPos;
1030 ImVec2 BackupCursorPosPrevLine;
1031 float BackupPrevLineTextBaseOffset;
1032 ImGuiLayoutType BackupLayout;
1042 ImVec2 BackupCursorMaxPos;
1043 ImVec2 BackupCursorPosPrevLine;
1045 ImVec1 BackupGroupOffset;
1046 ImVec2 BackupCurrLineSize;
1047 float BackupCurrLineTextBaseOffset;
1048 ImGuiID BackupActiveIdIsAlive;
1049 bool BackupActiveIdPreviousFrameIsAlive;
1050 bool BackupHoveredIdIsAlive;
1051 bool BackupIsSameLine;
1059 ImU32 NextTotalWidth;
1063 ImU16 OffsetShortcut;
1068 void Update(
float spacing,
bool window_reappearing);
1069 float DeclColumns(
float w_icon,
float w_label,
float w_shortcut,
float w_mark);
1070 void CalcNextTotalWidth(
bool update_offsets);
1080 void ClearFreeMemory() { ID = 0; TextA.clear(); }
1088 int CurLenW, CurLenA;
1098 bool SelectedAllMouseLock;
1100 ImGuiInputTextFlags Flags;
1102 int ReloadSelectionStart;
1103 int ReloadSelectionEnd;
1106 void ClearText() { CurLenW = CurLenA = 0; TextW[0] = 0; TextA[0] = 0; CursorClamp(); }
1107 void ClearFreeMemory() { TextW.clear(); TextA.clear(); InitialTextA.clear(); }
1108 int GetUndoAvailCount()
const {
return Stb.undostate.undo_point; }
1109 int GetRedoAvailCount()
const {
return IMSTB_TEXTEDIT_UNDOSTATECOUNT - Stb.undostate.redo_point; }
1110 void OnKeyPressed(
int key);
1113 void CursorAnimReset() { CursorAnim = -0.30f; }
1114 void CursorClamp() { Stb.cursor = ImMin(Stb.cursor, CurLenW); Stb.select_start = ImMin(Stb.select_start, CurLenW); Stb.select_end = ImMin(Stb.select_end, CurLenW); }
1115 bool HasSelection()
const {
return Stb.select_start != Stb.select_end; }
1116 void ClearSelection() { Stb.select_start = Stb.select_end = Stb.cursor; }
1117 int GetCursorPos()
const {
return Stb.cursor; }
1118 int GetSelectionStart()
const {
return Stb.select_start; }
1119 int GetSelectionEnd()
const {
return Stb.select_end; }
1120 void SelectAll() { Stb.select_start = 0; Stb.cursor = Stb.select_end = CurLenW; Stb.has_preferred_x = 0; }
1127 void ReloadUserBufAndSelectAll() { ReloadUserBuf =
true; ReloadSelectionStart = 0; ReloadSelectionEnd = INT_MAX; }
1128 void ReloadUserBufAndKeepSelection() { ReloadUserBuf =
true; ReloadSelectionStart = Stb.select_start; ReloadSelectionEnd = Stb.select_end; }
1129 void ReloadUserBufAndMoveToEnd() { ReloadUserBuf =
true; ReloadSelectionStart = ReloadSelectionEnd = INT_MAX; }
1133 enum ImGuiWindowRefreshFlags_
1135 ImGuiWindowRefreshFlags_None = 0,
1136 ImGuiWindowRefreshFlags_TryToAvoidRefresh = 1 << 0,
1137 ImGuiWindowRefreshFlags_RefreshOnHover = 1 << 1,
1138 ImGuiWindowRefreshFlags_RefreshOnFocus = 1 << 2,
1142 enum ImGuiNextWindowDataFlags_
1144 ImGuiNextWindowDataFlags_None = 0,
1145 ImGuiNextWindowDataFlags_HasPos = 1 << 0,
1146 ImGuiNextWindowDataFlags_HasSize = 1 << 1,
1147 ImGuiNextWindowDataFlags_HasContentSize = 1 << 2,
1148 ImGuiNextWindowDataFlags_HasCollapsed = 1 << 3,
1149 ImGuiNextWindowDataFlags_HasSizeConstraint = 1 << 4,
1150 ImGuiNextWindowDataFlags_HasFocus = 1 << 5,
1151 ImGuiNextWindowDataFlags_HasBgAlpha = 1 << 6,
1152 ImGuiNextWindowDataFlags_HasScroll = 1 << 7,
1153 ImGuiNextWindowDataFlags_HasChildFlags = 1 << 8,
1154 ImGuiNextWindowDataFlags_HasRefreshPolicy = 1 << 9,
1155 ImGuiNextWindowDataFlags_HasViewport = 1 << 10,
1156 ImGuiNextWindowDataFlags_HasDock = 1 << 11,
1157 ImGuiNextWindowDataFlags_HasWindowClass = 1 << 12,
1163 ImGuiNextWindowDataFlags Flags;
1166 ImGuiCond CollapsedCond;
1173 ImGuiChildFlags ChildFlags;
1176 ImRect SizeConstraintRect;
1177 ImGuiSizeCallback SizeCallback;
1178 void* SizeCallbackUserData;
1183 ImVec2 MenuBarOffsetMinVal;
1184 ImGuiWindowRefreshFlags RefreshFlagsVal;
1187 inline void ClearFlags() { Flags = ImGuiNextWindowDataFlags_None; }
1192 typedef ImS64 ImGuiSelectionUserData;
1194 enum ImGuiNextItemDataFlags_
1196 ImGuiNextItemDataFlags_None = 0,
1197 ImGuiNextItemDataFlags_HasWidth = 1 << 0,
1198 ImGuiNextItemDataFlags_HasOpen = 1 << 1,
1199 ImGuiNextItemDataFlags_HasShortcut = 1 << 2,
1204 ImGuiNextItemDataFlags Flags;
1205 ImGuiItemFlags ItemFlags;
1207 ImGuiSelectionUserData SelectionUserData;
1209 ImGuiKeyChord Shortcut;
1210 ImGuiInputFlags ShortcutFlags;
1212 ImGuiCond OpenCond : 8;
1215 inline void ClearFlags() { Flags = ImGuiNextItemDataFlags_None; ItemFlags = ImGuiItemFlags_None; }
1222 ImGuiItemFlags InFlags;
1223 ImGuiItemStatusFlags StatusFlags;
1229 ImGuiKeyChord Shortcut;
1240 ImGuiItemFlags InFlags;
1246 short SizeOfIDStack;
1247 short SizeOfColorStack;
1248 short SizeOfStyleVarStack;
1249 short SizeOfFontStack;
1250 short SizeOfFocusScopeStack;
1251 short SizeOfGroupStack;
1252 short SizeOfItemFlagsStack;
1253 short SizeOfBeginPopupStack;
1254 short SizeOfDisabledStack;
1294 void* GetVarPtr(
void* parent)
const {
return (
void*)((
unsigned char*)parent + Offset); }
1307 const char* PrintFmt;
1308 const char* ScanFmt;
1312 enum ImGuiDataTypePrivate_
1314 ImGuiDataType_String = ImGuiDataType_COUNT + 1,
1315 ImGuiDataType_Pointer,
1323 enum ImGuiPopupPositionPolicy
1325 ImGuiPopupPositionPolicy_Default,
1326 ImGuiPopupPositionPolicy_ComboBox,
1327 ImGuiPopupPositionPolicy_Tooltip,
1338 ImGuiID OpenParentId;
1342 ImGuiPopupData() { memset(
this, 0,
sizeof(*
this)); ParentNavLayer = OpenFrameCount = -1; }
1353 #define ImGuiKey_LegacyNativeKey_BEGIN 0 1354 #define ImGuiKey_LegacyNativeKey_END 512 1355 #define ImGuiKey_Keyboard_BEGIN (ImGuiKey_NamedKey_BEGIN) 1356 #define ImGuiKey_Keyboard_END (ImGuiKey_GamepadStart) 1357 #define ImGuiKey_Gamepad_BEGIN (ImGuiKey_GamepadStart) 1358 #define ImGuiKey_Gamepad_END (ImGuiKey_GamepadRStickDown + 1) 1359 #define ImGuiKey_Mouse_BEGIN (ImGuiKey_MouseLeft) 1360 #define ImGuiKey_Mouse_END (ImGuiKey_MouseWheelY + 1) 1361 #define ImGuiKey_Aliases_BEGIN (ImGuiKey_Mouse_BEGIN) 1362 #define ImGuiKey_Aliases_END (ImGuiKey_Mouse_END) 1365 #define ImGuiKey_NavKeyboardTweakSlow ImGuiMod_Ctrl 1366 #define ImGuiKey_NavKeyboardTweakFast ImGuiMod_Shift 1367 #define ImGuiKey_NavGamepadTweakSlow ImGuiKey_GamepadL1 1368 #define ImGuiKey_NavGamepadTweakFast ImGuiKey_GamepadR1 1369 #define ImGuiKey_NavGamepadActivate ImGuiKey_GamepadFaceDown 1370 #define ImGuiKey_NavGamepadCancel ImGuiKey_GamepadFaceRight 1371 #define ImGuiKey_NavGamepadMenu ImGuiKey_GamepadFaceLeft 1372 #define ImGuiKey_NavGamepadInput ImGuiKey_GamepadFaceUp 1374 enum ImGuiInputEventType
1376 ImGuiInputEventType_None = 0,
1377 ImGuiInputEventType_MousePos,
1378 ImGuiInputEventType_MouseWheel,
1379 ImGuiInputEventType_MouseButton,
1380 ImGuiInputEventType_MouseViewport,
1381 ImGuiInputEventType_Key,
1382 ImGuiInputEventType_Text,
1383 ImGuiInputEventType_Focus,
1384 ImGuiInputEventType_COUNT
1387 enum ImGuiInputSource
1389 ImGuiInputSource_None = 0,
1390 ImGuiInputSource_Mouse,
1391 ImGuiInputSource_Keyboard,
1392 ImGuiInputSource_Gamepad,
1393 ImGuiInputSource_COUNT
1408 ImGuiInputEventType
Type;
1409 ImGuiInputSource Source;
1421 bool AddedByTestEngine;
1427 #define ImGuiKeyOwner_Any ((ImGuiID)0) // Accept key that have an owner, UNLESS a call to SetKeyOwner() explicitly used ImGuiInputFlags_LockThisFrame or ImGuiInputFlags_LockUntilRelease. 1428 #define ImGuiKeyOwner_NoOwner ((ImGuiID)-1) // Require key to have no owner. 1431 typedef ImS16 ImGuiKeyRoutingIndex;
1436 ImGuiKeyRoutingIndex NextEntryIndex;
1438 ImU8 RoutingCurrScore;
1439 ImU8 RoutingNextScore;
1440 ImGuiID RoutingCurr;
1441 ImGuiID RoutingNext;
1443 ImGuiKeyRoutingData() { NextEntryIndex = -1; Mods = 0; RoutingCurrScore = RoutingNextScore = 255; RoutingCurr = RoutingNext = ImGuiKeyOwner_NoOwner; }
1450 ImGuiKeyRoutingIndex Index[ImGuiKey_NamedKey_COUNT];
1455 void Clear() {
for (
int n = 0; n < IM_ARRAYSIZE(Index); n++) Index[n] = -1; Entries.clear(); EntriesNext.clear(); }
1465 bool LockUntilRelease;
1467 ImGuiKeyOwnerData() { OwnerCurr = OwnerNext = ImGuiKeyOwner_NoOwner; LockThisFrame = LockUntilRelease =
false; }
1473 enum ImGuiInputFlagsPrivate_
1477 ImGuiInputFlags_RepeatRateDefault = 1 << 1,
1478 ImGuiInputFlags_RepeatRateNavMove = 1 << 2,
1479 ImGuiInputFlags_RepeatRateNavTweak = 1 << 3,
1482 ImGuiInputFlags_RepeatUntilRelease = 1 << 4,
1483 ImGuiInputFlags_RepeatUntilKeyModsChange = 1 << 5,
1484 ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone = 1 << 6,
1485 ImGuiInputFlags_RepeatUntilOtherKeyPress = 1 << 7,
1489 ImGuiInputFlags_LockThisFrame = 1 << 20,
1490 ImGuiInputFlags_LockUntilRelease = 1 << 21,
1493 ImGuiInputFlags_CondHovered = 1 << 22,
1494 ImGuiInputFlags_CondActive = 1 << 23,
1495 ImGuiInputFlags_CondDefault_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive,
1498 ImGuiInputFlags_RepeatRateMask_ = ImGuiInputFlags_RepeatRateDefault | ImGuiInputFlags_RepeatRateNavMove | ImGuiInputFlags_RepeatRateNavTweak,
1499 ImGuiInputFlags_RepeatUntilMask_ = ImGuiInputFlags_RepeatUntilRelease | ImGuiInputFlags_RepeatUntilKeyModsChange | ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone | ImGuiInputFlags_RepeatUntilOtherKeyPress,
1500 ImGuiInputFlags_RepeatMask_ = ImGuiInputFlags_Repeat | ImGuiInputFlags_RepeatRateMask_ | ImGuiInputFlags_RepeatUntilMask_,
1501 ImGuiInputFlags_CondMask_ = ImGuiInputFlags_CondHovered | ImGuiInputFlags_CondActive,
1502 ImGuiInputFlags_RouteTypeMask_ = ImGuiInputFlags_RouteActive | ImGuiInputFlags_RouteFocused | ImGuiInputFlags_RouteGlobal | ImGuiInputFlags_RouteAlways,
1503 ImGuiInputFlags_RouteOptionsMask_ = ImGuiInputFlags_RouteOverFocused | ImGuiInputFlags_RouteOverActive | ImGuiInputFlags_RouteUnlessBgFocused | ImGuiInputFlags_RouteFromRootWindow,
1504 ImGuiInputFlags_SupportedByIsKeyPressed = ImGuiInputFlags_RepeatMask_,
1505 ImGuiInputFlags_SupportedByIsMouseClicked = ImGuiInputFlags_Repeat,
1506 ImGuiInputFlags_SupportedByShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_,
1507 ImGuiInputFlags_SupportedBySetNextItemShortcut = ImGuiInputFlags_RepeatMask_ | ImGuiInputFlags_RouteTypeMask_ | ImGuiInputFlags_RouteOptionsMask_ | ImGuiInputFlags_Tooltip,
1508 ImGuiInputFlags_SupportedBySetKeyOwner = ImGuiInputFlags_LockThisFrame | ImGuiInputFlags_LockUntilRelease,
1509 ImGuiInputFlags_SupportedBySetItemKeyOwner = ImGuiInputFlags_SupportedBySetKeyOwner | ImGuiInputFlags_CondMask_,
1521 bool PosToIndexConvert;
1522 ImS8 PosToIndexOffsetMin;
1523 ImS8 PosToIndexOffsetMax;
1533 float LossynessOffset;
1539 void Reset(
ImGuiListClipper* clipper) { ListClipper = clipper; StepNo = ItemsFrozen = 0; Ranges.resize(0); }
1546 enum ImGuiActivateFlags_
1548 ImGuiActivateFlags_None = 0,
1549 ImGuiActivateFlags_PreferInput = 1 << 0,
1550 ImGuiActivateFlags_PreferTweak = 1 << 1,
1551 ImGuiActivateFlags_TryToPreserveState = 1 << 2,
1552 ImGuiActivateFlags_FromTabbing = 1 << 3,
1553 ImGuiActivateFlags_FromShortcut = 1 << 4,
1557 enum ImGuiScrollFlags_
1559 ImGuiScrollFlags_None = 0,
1560 ImGuiScrollFlags_KeepVisibleEdgeX = 1 << 0,
1561 ImGuiScrollFlags_KeepVisibleEdgeY = 1 << 1,
1562 ImGuiScrollFlags_KeepVisibleCenterX = 1 << 2,
1563 ImGuiScrollFlags_KeepVisibleCenterY = 1 << 3,
1564 ImGuiScrollFlags_AlwaysCenterX = 1 << 4,
1565 ImGuiScrollFlags_AlwaysCenterY = 1 << 5,
1566 ImGuiScrollFlags_NoScrollParent = 1 << 6,
1567 ImGuiScrollFlags_MaskX_ = ImGuiScrollFlags_KeepVisibleEdgeX | ImGuiScrollFlags_KeepVisibleCenterX | ImGuiScrollFlags_AlwaysCenterX,
1568 ImGuiScrollFlags_MaskY_ = ImGuiScrollFlags_KeepVisibleEdgeY | ImGuiScrollFlags_KeepVisibleCenterY | ImGuiScrollFlags_AlwaysCenterY,
1571 enum ImGuiNavHighlightFlags_
1573 ImGuiNavHighlightFlags_None = 0,
1574 ImGuiNavHighlightFlags_Compact = 1 << 1,
1575 ImGuiNavHighlightFlags_AlwaysDraw = 1 << 2,
1576 ImGuiNavHighlightFlags_NoRounding = 1 << 3,
1579 enum ImGuiNavMoveFlags_
1581 ImGuiNavMoveFlags_None = 0,
1582 ImGuiNavMoveFlags_LoopX = 1 << 0,
1583 ImGuiNavMoveFlags_LoopY = 1 << 1,
1584 ImGuiNavMoveFlags_WrapX = 1 << 2,
1585 ImGuiNavMoveFlags_WrapY = 1 << 3,
1586 ImGuiNavMoveFlags_WrapMask_ = ImGuiNavMoveFlags_LoopX | ImGuiNavMoveFlags_LoopY | ImGuiNavMoveFlags_WrapX | ImGuiNavMoveFlags_WrapY,
1587 ImGuiNavMoveFlags_AllowCurrentNavId = 1 << 4,
1588 ImGuiNavMoveFlags_AlsoScoreVisibleSet = 1 << 5,
1589 ImGuiNavMoveFlags_ScrollToEdgeY = 1 << 6,
1590 ImGuiNavMoveFlags_Forwarded = 1 << 7,
1591 ImGuiNavMoveFlags_DebugNoResult = 1 << 8,
1592 ImGuiNavMoveFlags_FocusApi = 1 << 9,
1593 ImGuiNavMoveFlags_IsTabbing = 1 << 10,
1594 ImGuiNavMoveFlags_IsPageMove = 1 << 11,
1595 ImGuiNavMoveFlags_Activate = 1 << 12,
1596 ImGuiNavMoveFlags_NoSelect = 1 << 13,
1597 ImGuiNavMoveFlags_NoSetNavHighlight = 1 << 14,
1598 ImGuiNavMoveFlags_NoClearActiveId = 1 << 15,
1603 ImGuiNavLayer_Main = 0,
1604 ImGuiNavLayer_Menu = 1,
1612 ImGuiID FocusScopeId;
1614 ImGuiItemFlags InFlags;
1618 ImGuiSelectionUserData SelectionUserData;
1621 void Clear() { Window = NULL; ID = FocusScopeId = 0; InFlags = 0; SelectionUserData = -1; DistBox = DistCenter = DistAxial = FLT_MAX; }
1635 enum ImGuiTypingSelectFlags_
1637 ImGuiTypingSelectFlags_None = 0,
1638 ImGuiTypingSelectFlags_AllowBackspace = 1 << 0,
1639 ImGuiTypingSelectFlags_AllowSingleCharMode = 1 << 1,
1645 ImGuiTypingSelectFlags Flags;
1646 int SearchBufferLen;
1647 const char* SearchBuffer;
1649 bool SingleCharMode;
1650 ImS8 SingleCharSize;
1657 char SearchBuffer[64];
1659 int LastRequestFrame = 0;
1660 float LastRequestTime = 0.0f;
1661 bool SingleCharModeLock =
false;
1664 void Clear() { SearchBuffer[0] = 0; SingleCharModeLock =
false; }
1672 enum ImGuiOldColumnFlags_
1674 ImGuiOldColumnFlags_None = 0,
1675 ImGuiOldColumnFlags_NoBorder = 1 << 0,
1676 ImGuiOldColumnFlags_NoResize = 1 << 1,
1677 ImGuiOldColumnFlags_NoPreserveWidths = 1 << 2,
1678 ImGuiOldColumnFlags_NoForceWithinWindow = 1 << 3,
1679 ImGuiOldColumnFlags_GrowParentContentsSize = 1 << 4,
1682 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS 1695 float OffsetNormBeforeResize;
1696 ImGuiOldColumnFlags Flags;
1705 ImGuiOldColumnFlags Flags;
1707 bool IsBeingResized;
1710 float OffMinX, OffMaxX;
1711 float LineMinY, LineMaxY;
1712 float HostCursorPosY;
1713 float HostCursorMaxPosX;
1714 ImRect HostInitialClipRect;
1715 ImRect HostBackupClipRect;
1716 ImRect HostBackupParentWorkRect;
1728 #define ImGuiSelectionUserData_Invalid ((ImGuiSelectionUserData)-1) 1730 #ifdef IMGUI_HAS_MULTI_SELECT 1732 #endif // #ifdef IMGUI_HAS_MULTI_SELECT 1738 #define DOCKING_HOST_DRAW_CHANNEL_BG 0 // Dock host: background fill 1739 #define DOCKING_HOST_DRAW_CHANNEL_FG 1 // Dock host: decorations and contents 1741 #ifdef IMGUI_HAS_DOCK 1744 enum ImGuiDockNodeFlagsPrivate_
1747 ImGuiDockNodeFlags_DockSpace = 1 << 10,
1748 ImGuiDockNodeFlags_CentralNode = 1 << 11,
1749 ImGuiDockNodeFlags_NoTabBar = 1 << 12,
1750 ImGuiDockNodeFlags_HiddenTabBar = 1 << 13,
1751 ImGuiDockNodeFlags_NoWindowMenuButton = 1 << 14,
1752 ImGuiDockNodeFlags_NoCloseButton = 1 << 15,
1753 ImGuiDockNodeFlags_NoResizeX = 1 << 16,
1754 ImGuiDockNodeFlags_NoResizeY = 1 << 17,
1755 ImGuiDockNodeFlags_DockedWindowsInFocusRoute= 1 << 18,
1759 ImGuiDockNodeFlags_NoDockingSplitOther = 1 << 19,
1760 ImGuiDockNodeFlags_NoDockingOverMe = 1 << 20,
1761 ImGuiDockNodeFlags_NoDockingOverOther = 1 << 21,
1762 ImGuiDockNodeFlags_NoDockingOverEmpty = 1 << 22,
1763 ImGuiDockNodeFlags_NoDocking = ImGuiDockNodeFlags_NoDockingOverMe | ImGuiDockNodeFlags_NoDockingOverOther | ImGuiDockNodeFlags_NoDockingOverEmpty | ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoDockingSplitOther,
1765 ImGuiDockNodeFlags_SharedFlagsInheritMask_ = ~0,
1766 ImGuiDockNodeFlags_NoResizeFlagsMask_ = ImGuiDockNodeFlags_NoResize | ImGuiDockNodeFlags_NoResizeX | ImGuiDockNodeFlags_NoResizeY,
1768 ImGuiDockNodeFlags_LocalFlagsTransferMask_ = ImGuiDockNodeFlags_NoDockingSplit | ImGuiDockNodeFlags_NoResizeFlagsMask_ | ImGuiDockNodeFlags_AutoHideTabBar | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton,
1769 ImGuiDockNodeFlags_SavedFlagsMask_ = ImGuiDockNodeFlags_NoResizeFlagsMask_ | ImGuiDockNodeFlags_DockSpace | ImGuiDockNodeFlags_CentralNode | ImGuiDockNodeFlags_NoTabBar | ImGuiDockNodeFlags_HiddenTabBar | ImGuiDockNodeFlags_NoWindowMenuButton | ImGuiDockNodeFlags_NoCloseButton,
1773 enum ImGuiDataAuthority_
1775 ImGuiDataAuthority_Auto,
1776 ImGuiDataAuthority_DockNode,
1777 ImGuiDataAuthority_Window,
1780 enum ImGuiDockNodeState
1782 ImGuiDockNodeState_Unknown,
1783 ImGuiDockNodeState_HostWindowHiddenBecauseSingleWindow,
1784 ImGuiDockNodeState_HostWindowHiddenBecauseWindowsAreResizing,
1785 ImGuiDockNodeState_HostWindowVisible,
1792 ImGuiDockNodeFlags SharedFlags;
1793 ImGuiDockNodeFlags LocalFlags;
1794 ImGuiDockNodeFlags LocalFlagsInWindows;
1795 ImGuiDockNodeFlags MergedFlags;
1796 ImGuiDockNodeState State;
1804 ImGuiAxis SplitAxis;
1812 int CountNodeWithWindows;
1814 int LastFrameActive;
1815 int LastFrameFocused;
1816 ImGuiID LastFocusedNodeId;
1817 ImGuiID SelectedTabId;
1818 ImGuiID WantCloseTabId;
1819 ImGuiID RefViewportId;
1820 ImGuiDataAuthority AuthorityForPos :3;
1821 ImGuiDataAuthority AuthorityForSize :3;
1822 ImGuiDataAuthority AuthorityForViewport :3;
1825 bool IsBgDrawnThisFrame :1;
1826 bool HasCloseButton :1;
1827 bool HasWindowMenuButton :1;
1828 bool HasCentralNodeChild :1;
1829 bool WantCloseAll :1;
1830 bool WantLockSizeOnce :1;
1831 bool WantMouseMove :1;
1832 bool WantHiddenTabBarUpdate :1;
1833 bool WantHiddenTabBarToggle :1;
1837 bool IsRootNode()
const {
return ParentNode == NULL; }
1838 bool IsDockSpace()
const {
return (MergedFlags & ImGuiDockNodeFlags_DockSpace) != 0; }
1839 bool IsFloatingNode()
const {
return ParentNode == NULL && (MergedFlags & ImGuiDockNodeFlags_DockSpace) == 0; }
1840 bool IsCentralNode()
const {
return (MergedFlags & ImGuiDockNodeFlags_CentralNode) != 0; }
1841 bool IsHiddenTabBar()
const {
return (MergedFlags & ImGuiDockNodeFlags_HiddenTabBar) != 0; }
1842 bool IsNoTabBar()
const {
return (MergedFlags & ImGuiDockNodeFlags_NoTabBar) != 0; }
1843 bool IsSplitNode()
const {
return ChildNodes[0] != NULL; }
1844 bool IsLeafNode()
const {
return ChildNodes[0] == NULL; }
1845 bool IsEmpty()
const {
return ChildNodes[0] == NULL && Windows.Size == 0; }
1846 ImRect Rect()
const {
return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
1848 void SetLocalFlags(ImGuiDockNodeFlags flags) { LocalFlags = flags; UpdateMergedFlags(); }
1849 void UpdateMergedFlags() { MergedFlags = SharedFlags | LocalFlags | LocalFlagsInWindows; }
1856 enum ImGuiWindowDockStyleCol
1858 ImGuiWindowDockStyleCol_Text,
1859 ImGuiWindowDockStyleCol_Tab,
1860 ImGuiWindowDockStyleCol_TabHovered,
1861 ImGuiWindowDockStyleCol_TabActive,
1862 ImGuiWindowDockStyleCol_TabUnfocused,
1863 ImGuiWindowDockStyleCol_TabUnfocusedActive,
1864 ImGuiWindowDockStyleCol_COUNT
1870 ImU32 Colors[ImGuiWindowDockStyleCol_COUNT];
1878 bool WantFullRebuild;
1882 #endif // #ifdef IMGUI_HAS_DOCK 1894 int LastFrameActive;
1895 int LastFocusedStampCount;
1896 ImGuiID LastNameHash;
1900 bool LastFocusedHadNavWindow;
1901 short PlatformMonitor;
1902 int BgFgDrawListsLastFrame[2];
1911 ImVec2 BuildWorkOffsetMin;
1912 ImVec2 BuildWorkOffsetMax;
1914 ImGuiViewportP() { Window = NULL; Idx = -1; LastFrameActive = BgFgDrawListsLastFrame[0] = BgFgDrawListsLastFrame[1] = LastFocusedStampCount = -1; LastNameHash = 0; Alpha = LastAlpha = 1.0f; LastFocusedHadNavWindow =
false; PlatformMonitor = -1; BgFgDrawLists[0] = BgFgDrawLists[1] = NULL; LastPlatformPos = LastPlatformSize = LastRendererSize =
ImVec2(FLT_MAX, FLT_MAX); }
1915 ~
ImGuiViewportP() {
if (BgFgDrawLists[0]) IM_DELETE(BgFgDrawLists[0]);
if (BgFgDrawLists[1]) IM_DELETE(BgFgDrawLists[1]); }
1916 void ClearRequestFlags() { PlatformRequestClose = PlatformRequestMove = PlatformRequestResize =
false; }
1919 ImVec2 CalcWorkRectPos(
const ImVec2& off_min)
const {
return ImVec2(Pos.x + off_min.x, Pos.y + off_min.y); }
1920 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)); }
1921 void UpdateWorkRect() { WorkPos = CalcWorkRectPos(WorkOffsetMin); WorkSize = CalcWorkRectSize(WorkOffsetMin, WorkOffsetMax); }
1924 ImRect GetMainRect()
const {
return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
1925 ImRect GetWorkRect()
const {
return ImRect(WorkPos.x, WorkPos.y, WorkPos.x + WorkSize.x, WorkPos.y + WorkSize.y); }
1926 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); }
1952 char* GetName() {
return (
char*)(
this + 1); }
1957 const char* TypeName;
1975 enum ImGuiLocKey :
int 1977 ImGuiLocKey_VersionStr,
1978 ImGuiLocKey_TableSizeOne,
1979 ImGuiLocKey_TableSizeAllFit,
1980 ImGuiLocKey_TableSizeAllDefault,
1981 ImGuiLocKey_TableResetOrder,
1982 ImGuiLocKey_WindowingMainMenuBar,
1983 ImGuiLocKey_WindowingPopup,
1984 ImGuiLocKey_WindowingUntitled,
1985 ImGuiLocKey_DockingHideTabBar,
1986 ImGuiLocKey_DockingHoldShiftToDock,
1987 ImGuiLocKey_DockingDragToUndockOrMoveNode,
2002 enum ImGuiDebugLogFlags_
2005 ImGuiDebugLogFlags_None = 0,
2006 ImGuiDebugLogFlags_EventActiveId = 1 << 0,
2007 ImGuiDebugLogFlags_EventFocus = 1 << 1,
2008 ImGuiDebugLogFlags_EventPopup = 1 << 2,
2009 ImGuiDebugLogFlags_EventNav = 1 << 3,
2010 ImGuiDebugLogFlags_EventClipper = 1 << 4,
2011 ImGuiDebugLogFlags_EventSelection = 1 << 5,
2012 ImGuiDebugLogFlags_EventIO = 1 << 6,
2013 ImGuiDebugLogFlags_EventInputRouting = 1 << 7,
2014 ImGuiDebugLogFlags_EventDocking = 1 << 8,
2015 ImGuiDebugLogFlags_EventViewport = 1 << 9,
2017 ImGuiDebugLogFlags_EventMask_ = ImGuiDebugLogFlags_EventActiveId | ImGuiDebugLogFlags_EventFocus | ImGuiDebugLogFlags_EventPopup | ImGuiDebugLogFlags_EventNav | ImGuiDebugLogFlags_EventClipper | ImGuiDebugLogFlags_EventSelection | ImGuiDebugLogFlags_EventIO | ImGuiDebugLogFlags_EventInputRouting | ImGuiDebugLogFlags_EventDocking | ImGuiDebugLogFlags_EventViewport,
2018 ImGuiDebugLogFlags_OutputToTTY = 1 << 20,
2019 ImGuiDebugLogFlags_OutputToTestEngine = 1 << 21,
2031 int TotalAllocCount;
2033 ImS16 LastEntriesIdx;
2041 bool ShowDebugLog =
false;
2042 bool ShowIDStackTool =
false;
2043 bool ShowWindowsRects =
false;
2044 bool ShowWindowsBeginOrder =
false;
2045 bool ShowTablesRects =
false;
2046 bool ShowDrawCmdMesh =
true;
2047 bool ShowDrawCmdBoundingBoxes =
true;
2048 bool ShowTextEncodingViewer =
false;
2049 bool ShowAtlasTintedWithTextColor =
false;
2050 bool ShowDockingNodes =
false;
2051 int ShowWindowsRectsType = -1;
2052 int ShowTablesRectsType = -1;
2053 int HighlightMonitorIdx = -1;
2054 ImGuiID HighlightViewportID = 0;
2060 ImS8 QueryFrameCount;
2062 ImGuiDataType DataType : 8;
2071 int LastActiveFrame;
2075 bool CopyToClipboardOnCtrlC;
2076 float CopyToClipboardLastTime;
2078 ImGuiIDStackTool() { memset(
this, 0,
sizeof(*
this)); CopyToClipboardLastTime = -FLT_MAX; }
2086 enum ImGuiContextHookType { ImGuiContextHookType_NewFramePre, ImGuiContextHookType_NewFramePost, ImGuiContextHookType_EndFramePre, ImGuiContextHookType_EndFramePost, ImGuiContextHookType_RenderPre, ImGuiContextHookType_RenderPost, ImGuiContextHookType_Shutdown, ImGuiContextHookType_PendingRemoval_ };
2091 ImGuiContextHookType
Type;
2093 ImGuiContextHookCallback Callback;
2106 bool FontAtlasOwnedByContext;
2110 ImGuiConfigFlags ConfigFlagsCurrFrame;
2111 ImGuiConfigFlags ConfigFlagsLastFrame;
2115 float CurrentDpiScale;
2119 int FrameCountEnded;
2120 int FrameCountPlatformEnded;
2121 int FrameCountRendered;
2122 bool WithinFrameScope;
2123 bool WithinFrameScopeWithImplicitWindow;
2124 bool WithinEndChild;
2126 bool TestEngineHookItems;
2132 ImGuiMouseSource InputEventsNextMouseSource;
2133 ImU32 InputEventsNextEventId;
2141 int WindowsActiveCount;
2142 ImVec2 WindowsHoverPadding;
2143 ImGuiID DebugBreakInWindow;
2149 ImVec2 WheelingWindowRefMousePos;
2150 int WheelingWindowStartFrame;
2151 int WheelingWindowScrolledFrame;
2152 float WheelingWindowReleaseTimer;
2153 ImVec2 WheelingWindowWheelRemainder;
2157 ImGuiID DebugHookIdInfo;
2159 ImGuiID HoveredIdPreviousFrame;
2160 bool HoveredIdAllowOverlap;
2161 bool HoveredIdDisabled;
2162 float HoveredIdTimer;
2163 float HoveredIdNotActiveTimer;
2165 ImGuiID ActiveIdIsAlive;
2166 float ActiveIdTimer;
2167 bool ActiveIdIsJustActivated;
2168 bool ActiveIdAllowOverlap;
2169 bool ActiveIdNoClearOnFocusLoss;
2170 bool ActiveIdHasBeenPressedBefore;
2171 bool ActiveIdHasBeenEditedBefore;
2172 bool ActiveIdHasBeenEditedThisFrame;
2173 bool ActiveIdFromShortcut;
2174 int ActiveIdMouseButton : 8;
2175 ImVec2 ActiveIdClickOffset;
2177 ImGuiInputSource ActiveIdSource;
2178 ImGuiID ActiveIdPreviousFrame;
2179 bool ActiveIdPreviousFrameIsAlive;
2180 bool ActiveIdPreviousFrameHasBeenEditedBefore;
2182 ImGuiID LastActiveId;
2183 float LastActiveIdTimer;
2189 double LastKeyModsChangeTime;
2190 double LastKeyModsChangeFromNoneTime;
2191 double LastKeyboardKeyPressTime;
2192 ImBitArrayForNamedKeys KeysMayBeCharInput;
2195 ImU32 ActiveIdUsingNavDirMask;
2196 bool ActiveIdUsingAllKeyboardKeys;
2197 ImGuiKeyChord DebugBreakInShortcutRouting;
2198 #ifndef IMGUI_DISABLE_OBSOLETE_KEYIO 2199 ImU32 ActiveIdUsingNavInputMask;
2203 ImGuiID CurrentFocusScopeId;
2204 ImGuiItemFlags CurrentItemFlags;
2205 ImGuiID DebugLocateId;
2209 bool DebugShowGroupRects;
2212 ImGuiCol DebugFlashStyleColorIdx;
2228 ImGuiID PlatformLastFocusedViewportId;
2230 ImRect PlatformMonitorsFullWorkRect;
2231 int ViewportCreatedCount;
2232 int PlatformWindowsCreatedCount;
2233 int ViewportFocusedStampCount;
2238 ImGuiID NavFocusScopeId;
2240 ImGuiID NavActivateId;
2241 ImGuiID NavActivateDownId;
2242 ImGuiID NavActivatePressedId;
2243 ImGuiActivateFlags NavActivateFlags;
2244 ImGuiID NavHighlightActivatedId;
2245 float NavHighlightActivatedTimer;
2246 ImGuiID NavJustMovedToId;
2247 ImGuiID NavJustMovedToFocusScopeId;
2248 ImGuiKeyChord NavJustMovedToKeyMods;
2249 ImGuiID NavNextActivateId;
2250 ImGuiActivateFlags NavNextActivateFlags;
2251 ImGuiInputSource NavInputSource;
2252 ImGuiNavLayer NavLayer;
2253 ImGuiSelectionUserData NavLastValidSelectionUserData;
2255 bool NavMousePosDirty;
2256 bool NavDisableHighlight;
2257 bool NavDisableMouseHover;
2261 bool NavInitRequest;
2262 bool NavInitRequestFromMove;
2264 bool NavMoveSubmitted;
2265 bool NavMoveScoringItems;
2266 bool NavMoveForwardToNextFrame;
2267 ImGuiNavMoveFlags NavMoveFlags;
2268 ImGuiScrollFlags NavMoveScrollFlags;
2269 ImGuiKeyChord NavMoveKeyMods;
2270 ImGuiDir NavMoveDir;
2271 ImGuiDir NavMoveDirForDebug;
2272 ImGuiDir NavMoveClipDir;
2274 ImRect NavScoringNoClipRect;
2275 int NavScoringDebugCount;
2277 int NavTabbingCounter;
2284 ImGuiKeyChord ConfigNavWindowingKeyNext;
2285 ImGuiKeyChord ConfigNavWindowingKeyPrev;
2289 float NavWindowingTimer;
2290 float NavWindowingHighlightAlpha;
2291 bool NavWindowingToggleLayer;
2292 ImGuiKey NavWindowingToggleKey;
2293 ImVec2 NavWindowingAccumDeltaPos;
2294 ImVec2 NavWindowingAccumDeltaSize;
2300 bool DragDropActive;
2301 bool DragDropWithinSource;
2302 bool DragDropWithinTarget;
2303 ImGuiDragDropFlags DragDropSourceFlags;
2304 int DragDropSourceFrameCount;
2305 int DragDropMouseButton;
2307 ImRect DragDropTargetRect;
2308 ImRect DragDropTargetClipRect;
2309 ImGuiID DragDropTargetId;
2310 ImGuiDragDropFlags DragDropAcceptFlags;
2311 float DragDropAcceptIdCurrRectSurface;
2312 ImGuiID DragDropAcceptIdCurr;
2313 ImGuiID DragDropAcceptIdPrev;
2314 int DragDropAcceptFrameCount;
2315 ImGuiID DragDropHoldJustPressedId;
2317 unsigned char DragDropPayloadBufLocal[16];
2320 int ClipperTempDataStacked;
2325 ImGuiID DebugBreakInTable;
2326 int TablesTempDataStacked;
2339 ImGuiID HoverItemDelayId;
2340 ImGuiID HoverItemDelayIdPreviousFrame;
2341 float HoverItemDelayTimer;
2342 float HoverItemDelayClearTimer;
2343 ImGuiID HoverItemUnlockedStationaryId;
2344 ImGuiID HoverWindowUnlockedStationaryId;
2347 ImGuiMouseCursor MouseCursor;
2348 float MouseStationaryTimer;
2349 ImVec2 MouseLastValidPos;
2354 ImFont InputTextPasswordFont;
2355 ImGuiID TempInputId;
2357 int BeginComboDepth;
2358 ImGuiColorEditFlags ColorEditOptions;
2359 ImGuiID ColorEditCurrentID;
2360 ImGuiID ColorEditSavedID;
2361 float ColorEditSavedHue;
2362 float ColorEditSavedSat;
2363 ImU32 ColorEditSavedColor;
2366 ImRect WindowResizeBorderExpectedRect;
2367 bool WindowResizeRelativeMode;
2368 float SliderGrabClickOffset;
2369 float SliderCurrentAccum;
2370 bool SliderCurrentAccumDirty;
2371 bool DragCurrentAccumDirty;
2372 float DragCurrentAccum;
2373 float DragSpeedDefaultRatio;
2374 float ScrollbarClickDeltaToGrabCenter;
2375 float DisabledAlphaBackup;
2376 short DisabledStackSize;
2377 short LockMarkEdited;
2378 short TooltipOverrideCount;
2386 ImGuiID PlatformImeViewport;
2394 bool SettingsLoaded;
2395 float SettingsDirtyTimer;
2404 const char* LocalizationTable[ImGuiLocKey_COUNT];
2408 ImGuiLogType LogType;
2409 ImFileHandle LogFile;
2411 const char* LogNextPrefix;
2412 const char* LogNextSuffix;
2414 bool LogLineFirstItem;
2416 int LogDepthToExpand;
2417 int LogDepthToExpandDefault;
2421 ImGuiDebugLogFlags DebugLogFlags;
2424 ImGuiDebugLogFlags DebugLogAutoDisableFlags;
2425 ImU8 DebugLogAutoDisableFrames;
2426 ImU8 DebugLocateFrames;
2427 bool DebugBreakInLocateId;
2428 ImGuiKeyChord DebugBreakKeyChord;
2429 ImS8 DebugBeginReturnValueCullDepth;
2430 bool DebugItemPickerActive;
2431 ImU8 DebugItemPickerMouseButton;
2432 ImGuiID DebugItemPickerBreakId;
2433 float DebugFlashStyleColorTime;
2434 ImVec4 DebugFlashStyleColorBackup;
2441 float FramerateSecPerFrame[60];
2442 int FramerateSecPerFrameIdx;
2443 int FramerateSecPerFrameCount;
2444 float FramerateSecPerFrameAccum;
2445 int WantCaptureMouseNextFrame;
2446 int WantCaptureKeyboardNextFrame;
2447 int WantTextInputNextFrame;
2449 char TempKeychordName[64];
2454 InputTextState.Ctx =
this;
2456 Initialized =
false;
2457 ConfigFlagsCurrFrame = ConfigFlagsLastFrame = ImGuiConfigFlags_None;
2458 FontAtlasOwnedByContext = shared_font_atlas ? false :
true;
2460 FontSize = FontBaseSize = CurrentDpiScale = 0.0f;
2461 IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(
ImFontAtlas)();
2464 FrameCountEnded = FrameCountPlatformEnded = FrameCountRendered = -1;
2465 WithinFrameScope = WithinFrameScopeWithImplicitWindow = WithinEndChild =
false;
2466 GcCompactAll =
false;
2467 TestEngineHookItems =
false;
2470 InputEventsNextMouseSource = ImGuiMouseSource_Mouse;
2471 InputEventsNextEventId = 1;
2473 WindowsActiveCount = 0;
2474 CurrentWindow = NULL;
2475 HoveredWindow = NULL;
2476 HoveredWindowUnderMovingWindow = NULL;
2477 MovingWindow = NULL;
2478 WheelingWindow = NULL;
2479 WheelingWindowStartFrame = WheelingWindowScrolledFrame = -1;
2480 WheelingWindowReleaseTimer = 0.0f;
2482 DebugHookIdInfo = 0;
2483 HoveredId = HoveredIdPreviousFrame = 0;
2484 HoveredIdAllowOverlap =
false;
2485 HoveredIdDisabled =
false;
2486 HoveredIdTimer = HoveredIdNotActiveTimer = 0.0f;
2488 ActiveIdIsAlive = 0;
2489 ActiveIdTimer = 0.0f;
2490 ActiveIdIsJustActivated =
false;
2491 ActiveIdAllowOverlap =
false;
2492 ActiveIdNoClearOnFocusLoss =
false;
2493 ActiveIdHasBeenPressedBefore =
false;
2494 ActiveIdHasBeenEditedBefore =
false;
2495 ActiveIdHasBeenEditedThisFrame =
false;
2496 ActiveIdFromShortcut =
false;
2497 ActiveIdClickOffset =
ImVec2(-1, -1);
2498 ActiveIdWindow = NULL;
2499 ActiveIdSource = ImGuiInputSource_None;
2500 ActiveIdMouseButton = -1;
2501 ActiveIdPreviousFrame = 0;
2502 ActiveIdPreviousFrameIsAlive =
false;
2503 ActiveIdPreviousFrameHasBeenEditedBefore =
false;
2504 ActiveIdPreviousFrameWindow = NULL;
2506 LastActiveIdTimer = 0.0f;
2508 LastKeyboardKeyPressTime = LastKeyModsChangeTime = LastKeyModsChangeFromNoneTime = -1.0;
2510 ActiveIdUsingNavDirMask = 0x00;
2511 ActiveIdUsingAllKeyboardKeys =
false;
2512 #ifndef IMGUI_DISABLE_OBSOLETE_KEYIO 2513 ActiveIdUsingNavInputMask = 0x00;
2516 CurrentFocusScopeId = 0;
2517 CurrentItemFlags = ImGuiItemFlags_None;
2518 DebugShowGroupRects =
false;
2520 CurrentViewport = NULL;
2521 MouseViewport = MouseLastHoveredViewport = NULL;
2522 PlatformLastFocusedViewportId = 0;
2523 ViewportCreatedCount = PlatformWindowsCreatedCount = 0;
2524 ViewportFocusedStampCount = 0;
2527 NavId = NavFocusScopeId = NavActivateId = NavActivateDownId = NavActivatePressedId = 0;
2528 NavJustMovedToId = NavJustMovedToFocusScopeId = NavNextActivateId = 0;
2529 NavActivateFlags = NavNextActivateFlags = ImGuiActivateFlags_None;
2530 NavHighlightActivatedId = 0;
2531 NavHighlightActivatedTimer = 0.0f;
2532 NavJustMovedToKeyMods = ImGuiMod_None;
2533 NavInputSource = ImGuiInputSource_Keyboard;
2534 NavLayer = ImGuiNavLayer_Main;
2535 NavLastValidSelectionUserData = ImGuiSelectionUserData_Invalid;
2536 NavIdIsAlive =
false;
2537 NavMousePosDirty =
false;
2538 NavDisableHighlight =
true;
2539 NavDisableMouseHover =
false;
2540 NavAnyRequest =
false;
2541 NavInitRequest =
false;
2542 NavInitRequestFromMove =
false;
2543 NavMoveSubmitted =
false;
2544 NavMoveScoringItems =
false;
2545 NavMoveForwardToNextFrame =
false;
2546 NavMoveFlags = ImGuiNavMoveFlags_None;
2547 NavMoveScrollFlags = ImGuiScrollFlags_None;
2548 NavMoveKeyMods = ImGuiMod_None;
2549 NavMoveDir = NavMoveDirForDebug = NavMoveClipDir = ImGuiDir_None;
2550 NavScoringDebugCount = 0;
2552 NavTabbingCounter = 0;
2556 ConfigNavWindowingKeyNext = IO.ConfigMacOSXBehaviors ? (ImGuiMod_Super | ImGuiKey_Tab) : (ImGuiMod_Ctrl | ImGuiKey_Tab);
2557 ConfigNavWindowingKeyPrev = IO.ConfigMacOSXBehaviors ? (ImGuiMod_Super | ImGuiMod_Shift | ImGuiKey_Tab) : (ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Tab);
2558 NavWindowingTarget = NavWindowingTargetAnim = NavWindowingListWindow = NULL;
2559 NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
2560 NavWindowingToggleLayer =
false;
2561 NavWindowingToggleKey = ImGuiKey_None;
2565 DragDropActive = DragDropWithinSource = DragDropWithinTarget =
false;
2566 DragDropSourceFlags = ImGuiDragDropFlags_None;
2567 DragDropSourceFrameCount = -1;
2568 DragDropMouseButton = -1;
2569 DragDropTargetId = 0;
2570 DragDropAcceptFlags = ImGuiDragDropFlags_None;
2571 DragDropAcceptIdCurrRectSurface = 0.0f;
2572 DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
2573 DragDropAcceptFrameCount = -1;
2574 DragDropHoldJustPressedId = 0;
2575 memset(DragDropPayloadBufLocal, 0,
sizeof(DragDropPayloadBufLocal));
2577 ClipperTempDataStacked = 0;
2579 CurrentTable = NULL;
2580 TablesTempDataStacked = 0;
2581 CurrentTabBar = NULL;
2583 HoverItemDelayId = HoverItemDelayIdPreviousFrame = HoverItemUnlockedStationaryId = HoverWindowUnlockedStationaryId = 0;
2584 HoverItemDelayTimer = HoverItemDelayClearTimer = 0.0f;
2586 MouseCursor = ImGuiMouseCursor_Arrow;
2587 MouseStationaryTimer = 0.0f;
2590 BeginMenuDepth = BeginComboDepth = 0;
2591 ColorEditOptions = ImGuiColorEditFlags_DefaultOptions_;
2592 ColorEditCurrentID = ColorEditSavedID = 0;
2593 ColorEditSavedHue = ColorEditSavedSat = 0.0f;
2594 ColorEditSavedColor = 0;
2595 WindowResizeRelativeMode =
false;
2596 SliderGrabClickOffset = 0.0f;
2597 SliderCurrentAccum = 0.0f;
2598 SliderCurrentAccumDirty =
false;
2599 DragCurrentAccumDirty =
false;
2600 DragCurrentAccum = 0.0f;
2601 DragSpeedDefaultRatio = 1.0f / 100.0f;
2602 ScrollbarClickDeltaToGrabCenter = 0.0f;
2603 DisabledAlphaBackup = 0.0f;
2604 DisabledStackSize = 0;
2606 TooltipOverrideCount = 0;
2608 PlatformImeData.InputPos =
ImVec2(0.0f, 0.0f);
2609 PlatformImeDataPrev.InputPos =
ImVec2(-1.0f, -1.0f);
2610 PlatformImeViewport = 0;
2612 DockNodeWindowMenuHandler = NULL;
2614 SettingsLoaded =
false;
2615 SettingsDirtyTimer = 0.0f;
2618 memset(LocalizationTable, 0,
sizeof(LocalizationTable));
2621 LogType = ImGuiLogType_None;
2622 LogNextPrefix = LogNextSuffix = NULL;
2624 LogLinePosY = FLT_MAX;
2625 LogLineFirstItem =
false;
2627 LogDepthToExpand = LogDepthToExpandDefault = 2;
2629 DebugLogFlags = ImGuiDebugLogFlags_OutputToTTY;
2631 DebugLogAutoDisableFlags = ImGuiDebugLogFlags_None;
2632 DebugLogAutoDisableFrames = 0;
2633 DebugLocateFrames = 0;
2634 DebugBeginReturnValueCullDepth = -1;
2635 DebugItemPickerActive =
false;
2636 DebugItemPickerMouseButton = ImGuiMouseButton_Left;
2637 DebugItemPickerBreakId = 0;
2638 DebugFlashStyleColorTime = 0.0f;
2639 DebugFlashStyleColorIdx = ImGuiCol_COUNT;
2640 DebugHoveredDockNode = NULL;
2643 DebugBreakInWindow = 0;
2644 DebugBreakInTable = 0;
2645 DebugBreakInLocateId =
false;
2646 DebugBreakKeyChord = ImGuiKey_Pause;
2647 DebugBreakInShortcutRouting = ImGuiKey_None;
2649 memset(FramerateSecPerFrame, 0,
sizeof(FramerateSecPerFrame));
2650 FramerateSecPerFrameIdx = FramerateSecPerFrameCount = 0;
2651 FramerateSecPerFrameAccum = 0.0f;
2652 WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
2653 memset(TempKeychordName, 0,
sizeof(TempKeychordName));
2668 ImVec2 CursorPosPrevLine;
2674 float CurrLineTextBaseOffset;
2675 float PrevLineTextBaseOffset;
2681 ImVec2 CursorStartPosLossyness;
2684 ImGuiNavLayer NavLayerCurrent;
2685 short NavLayersActiveMask;
2686 short NavLayersActiveMaskNext;
2687 bool NavIsScrollPushableX;
2688 bool NavHideHighlightOneFrame;
2689 bool NavWindowHasScrollY;
2692 bool MenuBarAppending;
2696 ImU32 TreeJumpToParentOnPopMask;
2700 int CurrentTableIdx;
2701 ImGuiLayoutType LayoutType;
2702 ImGuiLayoutType ParentLayoutType;
2703 ImU32 ModalDimBgColor;
2719 ImGuiWindowFlags Flags, FlagsPreviousFrame;
2720 ImGuiChildFlags ChildFlags;
2725 int ViewportAllowPlatformMonitorExtend;
2731 ImVec2 ContentSizeExplicit;
2733 float WindowRounding;
2734 float WindowBorderSize;
2735 float DecoOuterSizeX1, DecoOuterSizeY1;
2736 float DecoOuterSizeX2, DecoOuterSizeY2;
2737 float DecoInnerSizeX1, DecoInnerSizeY1;
2745 ImVec2 ScrollTargetCenterRatio;
2746 ImVec2 ScrollTargetEdgeSnapDist;
2748 bool ScrollbarX, ScrollbarY;
2754 bool WantCollapseToggle;
2759 bool IsFallbackWindow;
2760 bool IsExplicitChild;
2761 bool HasCloseButton;
2762 signed char ResizeBorderHovered;
2763 signed char ResizeBorderHeld;
2765 short BeginCountPreviousFrame;
2766 short BeginOrderWithinParent;
2767 short BeginOrderWithinContext;
2770 ImS8 AutoFitFramesX, AutoFitFramesY;
2771 bool AutoFitOnlyGrows;
2772 ImGuiDir AutoPosLastDirection;
2773 ImS8 HiddenFramesCanSkipItems;
2774 ImS8 HiddenFramesCannotSkipItems;
2775 ImS8 HiddenFramesForRenderOnly;
2776 ImS8 DisableInputsFrames;
2777 ImGuiCond SetWindowPosAllowFlags : 8;
2778 ImGuiCond SetWindowSizeAllowFlags : 8;
2779 ImGuiCond SetWindowCollapsedAllowFlags : 8;
2780 ImGuiCond SetWindowDockAllowFlags : 8;
2782 ImVec2 SetWindowPosPivot;
2795 ImRect ContentRegionRect;
2799 int LastFrameActive;
2800 int LastFrameJustFocused;
2801 float LastTimeActive;
2802 float ItemWidthDefault;
2805 float FontWindowScale;
2821 ImGuiID NavLastIds[ImGuiNavLayer_COUNT];
2822 ImRect NavRectRel[ImGuiNavLayer_COUNT];
2823 ImVec2 NavPreferredScoringPosRel[ImGuiNavLayer_COUNT];
2824 ImGuiID NavRootFocusScopeId;
2826 int MemoryDrawListIdxCapacity;
2827 int MemoryDrawListVtxCapacity;
2828 bool MemoryCompacted;
2831 bool DockIsActive :1;
2832 bool DockNodeIsVisible :1;
2833 bool DockTabIsVisible :1;
2834 bool DockTabWantClose :1;
2840 ImGuiItemStatusFlags DockTabItemStatusFlags;
2847 ImGuiID GetID(
const char* str,
const char* str_end = NULL);
2848 ImGuiID GetID(
const void* ptr);
2849 ImGuiID GetID(
int n);
2850 ImGuiID GetIDFromRectangle(
const ImRect& r_abs);
2853 ImRect Rect()
const {
return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
2854 float CalcFontSize()
const {
ImGuiContext& g = *Ctx;
float scale = g.FontBaseSize * FontWindowScale * FontDpiScale;
if (ParentWindow) scale *= ParentWindow->FontWindowScale;
return scale; }
2855 float TitleBarHeight()
const {
ImGuiContext& g = *Ctx;
return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + g.Style.FramePadding.y * 2.0f; }
2856 ImRect TitleBarRect()
const {
return ImRect(Pos,
ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
2857 float MenuBarHeight()
const {
ImGuiContext& g = *Ctx;
return (Flags & ImGuiWindowFlags_MenuBar) ? DC.MenuBarOffset.y + CalcFontSize() + g.Style.FramePadding.y * 2.0f : 0.0f; }
2858 ImRect MenuBarRect()
const {
float y1 = Pos.y + TitleBarHeight();
return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
2866 enum ImGuiTabBarFlagsPrivate_
2868 ImGuiTabBarFlags_DockNode = 1 << 20,
2869 ImGuiTabBarFlags_IsFocused = 1 << 21,
2870 ImGuiTabBarFlags_SaveSettings = 1 << 22,
2874 enum ImGuiTabItemFlagsPrivate_
2876 ImGuiTabItemFlags_SectionMask_ = ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing,
2877 ImGuiTabItemFlags_NoCloseButton = 1 << 20,
2878 ImGuiTabItemFlags_Button = 1 << 21,
2879 ImGuiTabItemFlags_Unsorted = 1 << 22,
2886 ImGuiTabItemFlags Flags;
2888 int LastFrameVisible;
2889 int LastFrameSelected;
2893 float RequestedWidth;
2896 ImS16 IndexDuringLayout;
2899 ImGuiTabItem() { memset(
this, 0,
sizeof(*
this)); LastFrameVisible = LastFrameSelected = -1; RequestedWidth = -1.0f; NameOffset = -1; BeginOrder = IndexDuringLayout = -1; }
2906 ImGuiTabBarFlags Flags;
2908 ImGuiID SelectedTabId;
2909 ImGuiID NextSelectedTabId;
2910 ImGuiID VisibleTabId;
2911 int CurrFrameVisible;
2912 int PrevFrameVisible;
2914 float CurrTabsContentsHeight;
2915 float PrevTabsContentsHeight;
2917 float WidthAllTabsIdeal;
2918 float ScrollingAnim;
2919 float ScrollingTarget;
2920 float ScrollingTargetDistToVisibility;
2921 float ScrollingSpeed;
2922 float ScrollingRectMinX;
2923 float ScrollingRectMaxX;
2924 float SeparatorMinX;
2925 float SeparatorMaxX;
2926 ImGuiID ReorderRequestTabId;
2927 ImS16 ReorderRequestOffset;
2930 bool VisibleTabWasSubmitted;
2932 ImS16 TabsActiveCount;
2933 ImS16 LastTabItemIdx;
2946 #define IM_COL32_DISABLE IM_COL32(0,0,0,1) // Special sentinel code which cannot be used as a regular color. 2947 #define IMGUI_TABLE_MAX_COLUMNS 512 // May be further lifted 2950 typedef ImS16 ImGuiTableColumnIdx;
2951 typedef ImU16 ImGuiTableDrawChannelIdx;
2959 ImGuiTableColumnFlags Flags;
2965 float StretchWeight;
2966 float InitStretchWeightOrWidth;
2972 float ContentMaxXFrozen;
2973 float ContentMaxXUnfrozen;
2974 float ContentMaxXHeadersUsed;
2975 float ContentMaxXHeadersIdeal;
2977 ImGuiTableColumnIdx DisplayOrder;
2978 ImGuiTableColumnIdx IndexWithinEnabledSet;
2979 ImGuiTableColumnIdx PrevEnabledColumn;
2980 ImGuiTableColumnIdx NextEnabledColumn;
2981 ImGuiTableColumnIdx SortOrder;
2982 ImGuiTableDrawChannelIdx DrawChannelCurrent;
2983 ImGuiTableDrawChannelIdx DrawChannelFrozen;
2984 ImGuiTableDrawChannelIdx DrawChannelUnfrozen;
2987 bool IsUserEnabledNextFrame;
2990 bool IsRequestOutput;
2992 bool IsPreserveWidthAuto;
2993 ImS8 NavLayerCurrent;
2995 ImU8 CannotSkipItemsQueue;
2996 ImU8 SortDirection : 2;
2997 ImU8 SortDirectionsAvailCount : 2;
2998 ImU8 SortDirectionsAvailMask : 4;
2999 ImU8 SortDirectionsAvailList;
3003 memset(
this, 0,
sizeof(*
this));
3004 StretchWeight = WidthRequest = -1.0f;
3006 DisplayOrder = IndexWithinEnabledSet = -1;
3007 PrevEnabledColumn = NextEnabledColumn = -1;
3009 SortDirection = ImGuiSortDirection_None;
3010 DrawChannelCurrent = DrawChannelFrozen = DrawChannelUnfrozen = (ImU8)-1;
3019 ImGuiTableColumnIdx Column;
3027 ImGuiTableColumnIdx Index;
3037 ImGuiID TableInstanceID;
3038 float LastOuterHeight;
3039 float LastTopHeadersRowHeight;
3040 float LastFrozenHeight;
3044 ImGuiTableInstanceData() { TableInstanceID = 0; LastOuterHeight = LastTopHeadersRowHeight = LastFrozenHeight = 0.0f; HoveredRowLast = HoveredRowNext = -1; }
3051 ImGuiTableFlags Flags;
3057 ImBitArrayPtr EnabledMaskByDisplayOrder;
3058 ImBitArrayPtr EnabledMaskByIndex;
3059 ImBitArrayPtr VisibleMaskByIndex;
3060 ImGuiTableFlags SettingsLoadedFlags;
3062 int LastFrameActive;
3066 ImS16 InstanceCurrent;
3067 ImS16 InstanceInteracted;
3071 float RowCellPaddingY;
3072 float RowTextBaseline;
3073 float RowIndentOffsetX;
3074 ImGuiTableRowFlags RowFlags : 16;
3075 ImGuiTableRowFlags LastRowFlags : 16;
3076 int RowBgColorCounter;
3077 ImU32 RowBgColor[2];
3078 ImU32 BorderColorStrong;
3079 ImU32 BorderColorLight;
3083 float MinColumnWidth;
3084 float OuterPaddingX;
3086 float CellSpacingX1;
3087 float CellSpacingX2;
3089 float ColumnsGivenWidth;
3090 float ColumnsAutoFitWidth;
3091 float ColumnsStretchSumWeights;
3092 float ResizedColumnNextWidth;
3093 float ResizeLockMinContentsX2;
3095 float AngledHeadersHeight;
3096 float AngledHeadersSlope;
3102 ImRect Bg0ClipRectForDrawCmd;
3103 ImRect Bg2ClipRectForDrawCmd;
3105 ImRect HostBackupInnerClipRect;
3115 ImGuiTableColumnIdx SortSpecsCount;
3116 ImGuiTableColumnIdx ColumnsEnabledCount;
3117 ImGuiTableColumnIdx ColumnsEnabledFixedCount;
3118 ImGuiTableColumnIdx DeclColumnsCount;
3119 ImGuiTableColumnIdx AngledHeadersCount;
3120 ImGuiTableColumnIdx HoveredColumnBody;
3121 ImGuiTableColumnIdx HoveredColumnBorder;
3122 ImGuiTableColumnIdx HighlightColumnHeader;
3123 ImGuiTableColumnIdx AutoFitSingleColumn;
3124 ImGuiTableColumnIdx ResizedColumn;
3125 ImGuiTableColumnIdx LastResizedColumn;
3126 ImGuiTableColumnIdx HeldHeaderColumn;
3127 ImGuiTableColumnIdx ReorderColumn;
3128 ImGuiTableColumnIdx ReorderColumnDir;
3129 ImGuiTableColumnIdx LeftMostEnabledColumn;
3130 ImGuiTableColumnIdx RightMostEnabledColumn;
3131 ImGuiTableColumnIdx LeftMostStretchedColumn;
3132 ImGuiTableColumnIdx RightMostStretchedColumn;
3133 ImGuiTableColumnIdx ContextPopupColumn;
3134 ImGuiTableColumnIdx FreezeRowsRequest;
3135 ImGuiTableColumnIdx FreezeRowsCount;
3136 ImGuiTableColumnIdx FreezeColumnsRequest;
3137 ImGuiTableColumnIdx FreezeColumnsCount;
3138 ImGuiTableColumnIdx RowCellDataCurrent;
3139 ImGuiTableDrawChannelIdx DummyDrawChannel;
3140 ImGuiTableDrawChannelIdx Bg2DrawChannelCurrent;
3141 ImGuiTableDrawChannelIdx Bg2DrawChannelUnfrozen;
3142 bool IsLayoutLocked;
3144 bool IsInitializing;
3145 bool IsSortSpecsDirty;
3146 bool IsUsingHeaders;
3147 bool IsContextPopupOpen;
3148 bool DisableDefaultContextMenu;
3149 bool IsSettingsRequestLoad;
3150 bool IsSettingsDirty;
3151 bool IsDefaultDisplayOrder;
3152 bool IsResetAllRequest;
3153 bool IsResetDisplayOrderRequest;
3154 bool IsUnfrozenRows;
3155 bool IsDefaultSizingPolicy;
3156 bool IsActiveIdAliveBeforeTable;
3157 bool IsActiveIdInTable;
3158 bool HasScrollbarYCurr;
3159 bool HasScrollbarYPrev;
3160 bool MemoryCompacted;
3163 ImGuiTable() { memset(
this, 0,
sizeof(*
this)); LastFrameActive = -1; }
3175 float LastTimeActive;
3176 float AngledHeadersExtraWidth;
3182 ImRect HostBackupWorkRect;
3183 ImRect HostBackupParentWorkRect;
3184 ImVec2 HostBackupPrevLineSize;
3185 ImVec2 HostBackupCurrLineSize;
3186 ImVec2 HostBackupCursorMaxPos;
3187 ImVec1 HostBackupColumnsOffset;
3188 float HostBackupItemWidth;
3189 int HostBackupItemWidthStackSize;
3197 float WidthOrWeight;
3199 ImGuiTableColumnIdx Index;
3200 ImGuiTableColumnIdx DisplayOrder;
3201 ImGuiTableColumnIdx SortOrder;
3202 ImU8 SortDirection : 2;
3208 WidthOrWeight = 0.0f;
3211 DisplayOrder = SortOrder = -1;
3212 SortDirection = ImGuiSortDirection_None;
3222 ImGuiTableFlags SaveFlags;
3224 ImGuiTableColumnIdx ColumnsCount;
3225 ImGuiTableColumnIdx ColumnsCountMax;
3245 inline ImGuiWindow* GetCurrentWindow() {
ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed =
true;
return g.CurrentWindow; }
3246 IMGUI_API
ImGuiWindow* FindWindowByID(ImGuiID
id);
3247 IMGUI_API
ImGuiWindow* FindWindowByName(
const char* name);
3248 IMGUI_API
void UpdateWindowParentAndRootLinks(
ImGuiWindow* window, ImGuiWindowFlags flags,
ImGuiWindow* parent_window);
3249 IMGUI_API
void UpdateWindowSkipRefresh(
ImGuiWindow* window);
3251 IMGUI_API
bool IsWindowChildOf(
ImGuiWindow* window,
ImGuiWindow* potential_parent,
bool popup_hierarchy,
bool dock_hierarchy);
3254 IMGUI_API
bool IsWindowNavFocusable(
ImGuiWindow* window);
3255 IMGUI_API
void SetWindowPos(
ImGuiWindow* window,
const ImVec2& pos, ImGuiCond cond = 0);
3256 IMGUI_API
void SetWindowSize(
ImGuiWindow* window,
const ImVec2& size, ImGuiCond cond = 0);
3257 IMGUI_API
void SetWindowCollapsed(
ImGuiWindow* window,
bool collapsed, ImGuiCond cond = 0);
3259 IMGUI_API
void SetWindowHiddenAndSkipItemsForCurrentFrame(
ImGuiWindow* window);
3260 inline void SetWindowParentWindowForFocusRoute(
ImGuiWindow* window,
ImGuiWindow* parent_window) { window->ParentWindowForFocusRoute = parent_window; }
3261 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); }
3262 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); }
3266 IMGUI_API
void FocusWindow(
ImGuiWindow* window, ImGuiFocusRequestFlags flags = 0);
3268 IMGUI_API
void BringWindowToFocusFront(
ImGuiWindow* window);
3269 IMGUI_API
void BringWindowToDisplayFront(
ImGuiWindow* window);
3270 IMGUI_API
void BringWindowToDisplayBack(
ImGuiWindow* window);
3272 IMGUI_API
int FindWindowDisplayIndex(
ImGuiWindow* window);
3276 IMGUI_API
void SetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags);
3279 IMGUI_API
void SetCurrentFont(
ImFont* font);
3280 inline ImFont* GetDefaultFont() {
ImGuiContext& g = *GImGui;
return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }
3281 inline ImDrawList* GetForegroundDrawList(
ImGuiWindow* window) {
return GetForegroundDrawList(window->Viewport); }
3285 IMGUI_API
void Initialize();
3286 IMGUI_API
void Shutdown();
3289 IMGUI_API
void UpdateInputEvents(
bool trickle_fast_inputs);
3290 IMGUI_API
void UpdateHoveredWindowAndCaptureFlags();
3291 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);
3292 IMGUI_API
void StartMouseMovingWindow(
ImGuiWindow* window);
3294 IMGUI_API
void UpdateMouseMovingWindowNewFrame();
3295 IMGUI_API
void UpdateMouseMovingWindowEndFrame();
3299 IMGUI_API
void RemoveContextHook(
ImGuiContext* context, ImGuiID hook_to_remove);
3300 IMGUI_API
void CallContextHooks(
ImGuiContext* context, ImGuiContextHookType type);
3309 IMGUI_API
ImGuiViewportP* FindHoveredViewportFromPlatformWindowStack(
const ImVec2& mouse_platform_pos);
3312 IMGUI_API
void MarkIniSettingsDirty();
3313 IMGUI_API
void MarkIniSettingsDirty(
ImGuiWindow* window);
3314 IMGUI_API
void ClearIniSettings();
3316 IMGUI_API
void RemoveSettingsHandler(
const char* type_name);
3323 IMGUI_API
void ClearWindowSettings(
const char* name);
3326 IMGUI_API
void LocalizeRegisterEntries(
const ImGuiLocEntry* entries,
int count);
3327 inline const char* LocalizeGetMsg(ImGuiLocKey key) {
ImGuiContext& g = *GImGui;
const char* msg = g.LocalizationTable[key];
return msg ? msg :
"*Missing Text*"; }
3330 IMGUI_API
void SetScrollX(
ImGuiWindow* window,
float scroll_x);
3331 IMGUI_API
void SetScrollY(
ImGuiWindow* window,
float scroll_y);
3332 IMGUI_API
void SetScrollFromPosX(
ImGuiWindow* window,
float local_x,
float center_x_ratio);
3333 IMGUI_API
void SetScrollFromPosY(
ImGuiWindow* window,
float local_y,
float center_y_ratio);
3336 IMGUI_API
void ScrollToItem(ImGuiScrollFlags flags = 0);
3337 IMGUI_API
void ScrollToRect(
ImGuiWindow* window,
const ImRect& rect, ImGuiScrollFlags flags = 0);
3340 inline void ScrollToBringRectIntoView(
ImGuiWindow* window,
const ImRect& rect) { ScrollToRect(window, rect, ImGuiScrollFlags_KeepVisibleEdgeY); }
3344 inline ImGuiItemStatusFlags GetItemStatusFlags(){
ImGuiContext& g = *GImGui;
return g.LastItemData.StatusFlags; }
3345 inline ImGuiItemFlags GetItemFlags() {
ImGuiContext& g = *GImGui;
return g.LastItemData.InFlags; }
3346 inline ImGuiID GetActiveID() {
ImGuiContext& g = *GImGui;
return g.ActiveId; }
3347 inline ImGuiID GetFocusID() {
ImGuiContext& g = *GImGui;
return g.NavId; }
3348 IMGUI_API
void SetActiveID(ImGuiID
id,
ImGuiWindow* window);
3349 IMGUI_API
void SetFocusID(ImGuiID
id,
ImGuiWindow* window);
3350 IMGUI_API
void ClearActiveID();
3351 IMGUI_API ImGuiID GetHoveredID();
3352 IMGUI_API
void SetHoveredID(ImGuiID
id);
3353 IMGUI_API
void KeepAliveID(ImGuiID
id);
3354 IMGUI_API
void MarkItemEdited(ImGuiID
id);
3355 IMGUI_API
void PushOverrideID(ImGuiID
id);
3356 IMGUI_API ImGuiID GetIDWithSeed(
const char* str_id_begin,
const char* str_id_end, ImGuiID seed);
3357 IMGUI_API ImGuiID GetIDWithSeed(
int n, ImGuiID seed);
3360 IMGUI_API
void ItemSize(
const ImVec2& size,
float text_baseline_y = -1.0f);
3361 inline void ItemSize(
const ImRect& bb,
float text_baseline_y = -1.0f) { ItemSize(bb.GetSize(), text_baseline_y); }
3362 IMGUI_API
bool ItemAdd(
const ImRect& bb, ImGuiID
id,
const ImRect* nav_bb = NULL, ImGuiItemFlags extra_flags = 0);
3363 IMGUI_API
bool ItemHoverable(
const ImRect& bb, ImGuiID
id, ImGuiItemFlags item_flags);
3364 IMGUI_API
bool IsWindowContentHoverable(
ImGuiWindow* window, ImGuiHoveredFlags flags = 0);
3365 IMGUI_API
bool IsClippedEx(
const ImRect& bb, ImGuiID
id);
3366 IMGUI_API
void SetLastItemData(ImGuiID item_id, ImGuiItemFlags in_flags, ImGuiItemStatusFlags status_flags,
const ImRect& item_rect);
3367 IMGUI_API
ImVec2 CalcItemSize(
ImVec2 size,
float default_w,
float default_h);
3368 IMGUI_API
float CalcWrapWidthForPos(
const ImVec2& pos,
float wrap_pos_x);
3369 IMGUI_API
void PushMultiItemsWidths(
int components,
float width_full);
3370 IMGUI_API
bool IsItemToggledSelection();
3371 IMGUI_API
ImVec2 GetContentRegionMaxAbs();
3375 IMGUI_API
void PushItemFlag(ImGuiItemFlags option,
bool enabled);
3376 IMGUI_API
void PopItemFlag();
3380 IMGUI_API
void LogBegin(ImGuiLogType type,
int auto_open_depth);
3381 IMGUI_API
void LogToBuffer(
int auto_open_depth = -1);
3382 IMGUI_API
void LogRenderedText(
const ImVec2* ref_pos,
const char* text,
const char* text_end = NULL);
3383 IMGUI_API
void LogSetNextTextDecoration(
const char* prefix,
const char* suffix);
3386 IMGUI_API
bool BeginChildEx(
const char* name, ImGuiID
id,
const ImVec2& size_arg, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags);
3387 IMGUI_API
void OpenPopupEx(ImGuiID
id, ImGuiPopupFlags popup_flags = ImGuiPopupFlags_None);
3388 IMGUI_API
void ClosePopupToLevel(
int remaining,
bool restore_focus_to_window_under_popup);
3389 IMGUI_API
void ClosePopupsOverWindow(
ImGuiWindow* ref_window,
bool restore_focus_to_window_under_popup);
3390 IMGUI_API
void ClosePopupsExceptModals();
3391 IMGUI_API
bool IsPopupOpen(ImGuiID
id, ImGuiPopupFlags popup_flags);
3392 IMGUI_API
bool BeginPopupEx(ImGuiID
id, ImGuiWindowFlags extra_flags);
3393 IMGUI_API
bool BeginTooltipEx(ImGuiTooltipFlags tooltip_flags, ImGuiWindowFlags extra_window_flags);
3394 IMGUI_API
bool BeginTooltipHidden();
3397 IMGUI_API
ImGuiWindow* GetTopMostAndVisiblePopupModal();
3400 IMGUI_API
ImVec2 FindBestWindowPosForPopupEx(
const ImVec2& ref_pos,
const ImVec2& size, ImGuiDir* last_dir,
const ImRect& r_outer,
const ImRect& r_avoid, ImGuiPopupPositionPolicy policy);
3403 IMGUI_API
bool BeginViewportSideBar(
const char* name,
ImGuiViewport* viewport, ImGuiDir dir,
float size, ImGuiWindowFlags window_flags);
3404 IMGUI_API
bool BeginMenuEx(
const char* label,
const char* icon,
bool enabled =
true);
3405 IMGUI_API
bool MenuItemEx(
const char* label,
const char* icon,
const char* shortcut = NULL,
bool selected =
false,
bool enabled =
true);
3408 IMGUI_API
bool BeginComboPopup(ImGuiID popup_id,
const ImRect& bb, ImGuiComboFlags flags);
3409 IMGUI_API
bool BeginComboPreview();
3410 IMGUI_API
void EndComboPreview();
3413 IMGUI_API
void NavInitWindow(
ImGuiWindow* window,
bool force_reinit);
3414 IMGUI_API
void NavInitRequestApplyResult();
3415 IMGUI_API
bool NavMoveRequestButNoResultYet();
3416 IMGUI_API
void NavMoveRequestSubmit(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags);
3417 IMGUI_API
void NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags);
3418 IMGUI_API
void NavMoveRequestResolveWithLastItem(
ImGuiNavItemData* result);
3420 IMGUI_API
void NavMoveRequestCancel();
3421 IMGUI_API
void NavMoveRequestApplyResult();
3422 IMGUI_API
void NavMoveRequestTryWrapping(
ImGuiWindow* window, ImGuiNavMoveFlags move_flags);
3423 IMGUI_API
void NavHighlightActivated(ImGuiID
id);
3424 IMGUI_API
void NavClearPreferredPosForAxis(ImGuiAxis axis);
3425 IMGUI_API
void NavRestoreHighlightAfterMove();
3426 IMGUI_API
void NavUpdateCurrentWindowIsScrollPushableX();
3428 IMGUI_API
void SetNavID(ImGuiID
id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id,
const ImRect& rect_rel);
3429 IMGUI_API
void SetNavFocusScope(ImGuiID focus_scope_id);
3434 IMGUI_API
void FocusItem();
3435 IMGUI_API
void ActivateItemByID(ImGuiID
id);
3439 inline bool IsNamedKey(ImGuiKey key) {
return key >= ImGuiKey_NamedKey_BEGIN && key < ImGuiKey_NamedKey_END; }
3440 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; }
3441 inline bool IsLegacyKey(ImGuiKey key) {
return key >= ImGuiKey_LegacyNativeKey_BEGIN && key < ImGuiKey_LegacyNativeKey_END; }
3442 inline bool IsKeyboardKey(ImGuiKey key) {
return key >= ImGuiKey_Keyboard_BEGIN && key < ImGuiKey_Keyboard_END; }
3443 inline bool IsGamepadKey(ImGuiKey key) {
return key >= ImGuiKey_Gamepad_BEGIN && key < ImGuiKey_Gamepad_END; }
3444 inline bool IsMouseKey(ImGuiKey key) {
return key >= ImGuiKey_Mouse_BEGIN && key < ImGuiKey_Mouse_END; }
3445 inline bool IsAliasKey(ImGuiKey key) {
return key >= ImGuiKey_Aliases_BEGIN && key < ImGuiKey_Aliases_END; }
3446 inline bool IsModKey(ImGuiKey key) {
return key >= ImGuiKey_LeftCtrl && key <= ImGuiKey_RightSuper; }
3447 ImGuiKeyChord FixupKeyChord(ImGuiKeyChord key_chord);
3448 inline ImGuiKey ConvertSingleModFlagToKey(ImGuiKey key)
3450 if (key == ImGuiMod_Ctrl)
return ImGuiKey_ReservedForModCtrl;
3451 if (key == ImGuiMod_Shift)
return ImGuiKey_ReservedForModShift;
3452 if (key == ImGuiMod_Alt)
return ImGuiKey_ReservedForModAlt;
3453 if (key == ImGuiMod_Super)
return ImGuiKey_ReservedForModSuper;
3459 IMGUI_API
const char* GetKeyChordName(ImGuiKeyChord key_chord);
3460 inline ImGuiKey MouseButtonToKey(ImGuiMouseButton button) { IM_ASSERT(button >= 0 && button < ImGuiMouseButton_COUNT);
return (ImGuiKey)(ImGuiKey_MouseLeft + button); }
3461 IMGUI_API
bool IsMouseDragPastThreshold(ImGuiMouseButton button,
float lock_threshold = -1.0f);
3462 IMGUI_API
ImVec2 GetKeyMagnitude2d(ImGuiKey key_left, ImGuiKey key_right, ImGuiKey key_up, ImGuiKey key_down);
3463 IMGUI_API
float GetNavTweakPressedAmount(ImGuiAxis axis);
3464 IMGUI_API
int CalcTypematicRepeatAmount(
float t0,
float t1,
float repeat_delay,
float repeat_rate);
3465 IMGUI_API
void GetTypematicRepeatRate(ImGuiInputFlags flags,
float* repeat_delay,
float* repeat_rate);
3466 IMGUI_API
void TeleportMousePos(
const ImVec2& pos);
3467 IMGUI_API
void SetActiveIdUsingAllKeyboardKeys();
3468 inline bool IsActiveIdUsingNavDir(ImGuiDir dir) {
ImGuiContext& g = *GImGui;
return (g.ActiveIdUsingNavDirMask & (1 << dir)) != 0; }
3481 IMGUI_API ImGuiID GetKeyOwner(ImGuiKey key);
3482 IMGUI_API
void SetKeyOwner(ImGuiKey key, ImGuiID owner_id, ImGuiInputFlags flags = 0);
3483 IMGUI_API
void SetKeyOwnersForKeyChord(ImGuiKeyChord key, ImGuiID owner_id, ImGuiInputFlags flags = 0);
3484 IMGUI_API
void SetItemKeyOwner(ImGuiKey key, ImGuiInputFlags flags = 0);
3485 IMGUI_API
bool TestKeyOwner(ImGuiKey key, ImGuiID owner_id);
3486 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]; }
3494 IMGUI_API
bool IsKeyDown(ImGuiKey key, ImGuiID owner_id);
3495 IMGUI_API
bool IsKeyPressed(ImGuiKey key, ImGuiInputFlags flags, ImGuiID owner_id = 0);
3496 IMGUI_API
bool IsKeyReleased(ImGuiKey key, ImGuiID owner_id);
3497 IMGUI_API
bool IsKeyChordPressed(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id = 0);
3498 IMGUI_API
bool IsMouseDown(ImGuiMouseButton button, ImGuiID owner_id);
3499 IMGUI_API
bool IsMouseClicked(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id = 0);
3500 IMGUI_API
bool IsMouseReleased(ImGuiMouseButton button, ImGuiID owner_id);
3501 IMGUI_API
bool IsMouseDoubleClicked(ImGuiMouseButton button, ImGuiID owner_id);
3517 IMGUI_API
bool Shortcut(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id);
3518 IMGUI_API
bool SetShortcutRouting(ImGuiKeyChord key_chord, ImGuiInputFlags flags, ImGuiID owner_id);
3519 IMGUI_API
bool TestShortcutRouting(ImGuiKeyChord key_chord, ImGuiID owner_id);
3524 IMGUI_API
void DockContextInitialize(
ImGuiContext* ctx);
3526 IMGUI_API
void DockContextClearNodes(
ImGuiContext* ctx, ImGuiID root_id,
bool clear_settings_refs);
3527 IMGUI_API
void DockContextRebuildNodes(
ImGuiContext* ctx);
3528 IMGUI_API
void DockContextNewFrameUpdateUndocking(
ImGuiContext* ctx);
3529 IMGUI_API
void DockContextNewFrameUpdateDocking(
ImGuiContext* ctx);
3531 IMGUI_API ImGuiID DockContextGenNodeID(
ImGuiContext* ctx);
3535 IMGUI_API
void DockContextProcessUndockWindow(
ImGuiContext* ctx,
ImGuiWindow* window,
bool clear_persistent_docking_ref =
true);
3540 IMGUI_API
bool DockNodeBeginAmendTabBar(
ImGuiDockNode* node);
3541 IMGUI_API
void DockNodeEndAmendTabBar();
3542 inline ImGuiDockNode* DockNodeGetRootNode(
ImGuiDockNode* node) {
while (node->ParentNode) node = node->ParentNode;
return node; }
3543 inline bool DockNodeIsInHierarchyOf(
ImGuiDockNode* node,
ImGuiDockNode* parent) {
while (node) {
if (node == parent)
return true; node = node->ParentNode; }
return false; }
3544 inline int DockNodeGetDepth(
const ImGuiDockNode* node) {
int depth = 0;
while (node->ParentNode) { node = node->ParentNode; depth++; }
return depth; }
3545 inline ImGuiID DockNodeGetWindowMenuButtonId(
const ImGuiDockNode* node) {
return ImHashStr(
"#COLLAPSE", 0, node->ID); }
3547 IMGUI_API
bool GetWindowAlwaysWantOwnTabBar(
ImGuiWindow* window);
3548 IMGUI_API
void BeginDocked(
ImGuiWindow* window,
bool* p_open);
3549 IMGUI_API
void BeginDockableDragDropSource(
ImGuiWindow* window);
3550 IMGUI_API
void BeginDockableDragDropTarget(
ImGuiWindow* window);
3551 IMGUI_API
void SetWindowDock(
ImGuiWindow* window, ImGuiID dock_id, ImGuiCond cond);
3562 IMGUI_API
void DockBuilderDockWindow(
const char* window_name, ImGuiID node_id);
3563 IMGUI_API
ImGuiDockNode*DockBuilderGetNode(ImGuiID node_id);
3564 inline ImGuiDockNode* DockBuilderGetCentralNode(ImGuiID node_id) {
ImGuiDockNode* node = DockBuilderGetNode(node_id);
if (!node)
return NULL;
return DockNodeGetRootNode(node)->CentralNode; }
3565 IMGUI_API ImGuiID DockBuilderAddNode(ImGuiID node_id = 0, ImGuiDockNodeFlags flags = 0);
3566 IMGUI_API
void DockBuilderRemoveNode(ImGuiID node_id);
3567 IMGUI_API
void DockBuilderRemoveNodeDockedWindows(ImGuiID node_id,
bool clear_settings_refs =
true);
3568 IMGUI_API
void DockBuilderRemoveNodeChildNodes(ImGuiID node_id);
3569 IMGUI_API
void DockBuilderSetNodePos(ImGuiID node_id,
ImVec2 pos);
3570 IMGUI_API
void DockBuilderSetNodeSize(ImGuiID node_id,
ImVec2 size);
3571 IMGUI_API ImGuiID DockBuilderSplitNode(ImGuiID node_id, ImGuiDir split_dir,
float size_ratio_for_node_at_dir, ImGuiID* out_id_at_dir, ImGuiID* out_id_at_opposite_dir);
3572 IMGUI_API
void DockBuilderCopyDockSpace(ImGuiID src_dockspace_id, ImGuiID dst_dockspace_id,
ImVector<const char*>* in_window_remap_pairs);
3573 IMGUI_API
void DockBuilderCopyNode(ImGuiID src_node_id, ImGuiID dst_node_id,
ImVector<ImGuiID>* out_node_remap_pairs);
3574 IMGUI_API
void DockBuilderCopyWindowSettings(
const char* src_name,
const char* dst_name);
3575 IMGUI_API
void DockBuilderFinish(ImGuiID node_id);
3585 IMGUI_API
void PushFocusScope(ImGuiID
id);
3586 IMGUI_API
void PopFocusScope();
3587 inline ImGuiID GetCurrentFocusScope() {
ImGuiContext& g = *GImGui;
return g.CurrentFocusScopeId; }
3590 IMGUI_API
bool IsDragDropActive();
3591 IMGUI_API
bool BeginDragDropTargetCustom(
const ImRect& bb, ImGuiID
id);
3592 IMGUI_API
void ClearDragDrop();
3593 IMGUI_API
bool IsDragDropPayloadBeingAccepted();
3594 IMGUI_API
void RenderDragDropTargetRect(
const ImRect& bb,
const ImRect& item_clip_rect);
3597 IMGUI_API
ImGuiTypingSelectRequest* GetTypingSelectRequest(ImGuiTypingSelectFlags flags = ImGuiTypingSelectFlags_None);
3598 IMGUI_API
int TypingSelectFindMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char* (*get_item_name_func)(
void*,
int),
void* user_data,
int nav_item_idx);
3599 IMGUI_API
int TypingSelectFindNextSingleCharMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char* (*get_item_name_func)(
void*,
int),
void* user_data,
int nav_item_idx);
3600 IMGUI_API
int TypingSelectFindBestLeadingMatch(
ImGuiTypingSelectRequest* req,
int items_count,
const char* (*get_item_name_func)(
void*,
int),
void* user_data);
3603 IMGUI_API
void SetWindowClipRectBeforeSetChannel(
ImGuiWindow* window,
const ImRect& clip_rect);
3604 IMGUI_API
void BeginColumns(
const char* str_id,
int count, ImGuiOldColumnFlags flags = 0);
3605 IMGUI_API
void EndColumns();
3606 IMGUI_API
void PushColumnClipRect(
int column_index);
3607 IMGUI_API
void PushColumnsBackground();
3608 IMGUI_API
void PopColumnsBackground();
3609 IMGUI_API ImGuiID GetColumnsID(
const char* str_id,
int count);
3611 IMGUI_API
float GetColumnOffsetFromNorm(
const ImGuiOldColumns* columns,
float offset_norm);
3612 IMGUI_API
float GetColumnNormFromOffset(
const ImGuiOldColumns* columns,
float offset);
3615 IMGUI_API
void TableOpenContextMenu(
int column_n = -1);
3616 IMGUI_API
void TableSetColumnWidth(
int column_n,
float width);
3617 IMGUI_API
void TableSetColumnSortDirection(
int column_n, ImGuiSortDirection sort_direction,
bool append_to_sort_specs);
3618 IMGUI_API
int TableGetHoveredColumn();
3619 IMGUI_API
int TableGetHoveredRow();
3620 IMGUI_API
float TableGetHeaderRowHeight();
3621 IMGUI_API
float TableGetHeaderAngledMaxLabelWidth();
3622 IMGUI_API
void TablePushBackgroundChannel();
3623 IMGUI_API
void TablePopBackgroundChannel();
3624 IMGUI_API
void TableAngledHeadersRowEx(ImGuiID row_id,
float angle,
float max_label_width,
const ImGuiTableHeaderData* data,
int data_count);
3628 IMGUI_API
ImGuiTable* TableFindByID(ImGuiID
id);
3629 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);
3630 IMGUI_API
void TableBeginInitMemory(
ImGuiTable* table,
int columns_count);
3631 IMGUI_API
void TableBeginApplyRequests(
ImGuiTable* table);
3632 IMGUI_API
void TableSetupDrawChannels(
ImGuiTable* table);
3633 IMGUI_API
void TableUpdateLayout(
ImGuiTable* table);
3634 IMGUI_API
void TableUpdateBorders(
ImGuiTable* table);
3635 IMGUI_API
void TableUpdateColumnsWeightFromWidth(
ImGuiTable* table);
3636 IMGUI_API
void TableDrawBorders(
ImGuiTable* table);
3637 IMGUI_API
void TableDrawDefaultContextMenu(
ImGuiTable* table, ImGuiTableFlags flags_for_section_to_display);
3638 IMGUI_API
bool TableBeginContextMenuPopup(
ImGuiTable* table);
3639 IMGUI_API
void TableMergeDrawChannels(
ImGuiTable* table);
3640 inline ImGuiTableInstanceData* TableGetInstanceData(
ImGuiTable* table,
int instance_no) {
if (instance_no == 0)
return &table->InstanceDataFirst;
return &table->InstanceDataExtra[instance_no - 1]; }
3641 inline ImGuiID TableGetInstanceID(
ImGuiTable* table,
int instance_no) {
return TableGetInstanceData(table, instance_no)->TableInstanceID; }
3642 IMGUI_API
void TableSortSpecsSanitize(
ImGuiTable* table);
3643 IMGUI_API
void TableSortSpecsBuild(
ImGuiTable* table);
3644 IMGUI_API ImGuiSortDirection TableGetColumnNextSortDirection(
ImGuiTableColumn* column);
3647 IMGUI_API
void TableBeginRow(
ImGuiTable* table);
3648 IMGUI_API
void TableEndRow(
ImGuiTable* table);
3649 IMGUI_API
void TableBeginCell(
ImGuiTable* table,
int column_n);
3650 IMGUI_API
void TableEndCell(
ImGuiTable* table);
3651 IMGUI_API
ImRect TableGetCellBgRect(
const ImGuiTable* table,
int column_n);
3652 IMGUI_API
const char* TableGetColumnName(
const ImGuiTable* table,
int column_n);
3653 IMGUI_API ImGuiID TableGetColumnResizeID(
ImGuiTable* table,
int column_n,
int instance_no = 0);
3654 IMGUI_API
float TableGetMaxColumnWidth(
const ImGuiTable* table,
int column_n);
3655 IMGUI_API
void TableSetColumnWidthAutoSingle(
ImGuiTable* table,
int column_n);
3656 IMGUI_API
void TableSetColumnWidthAutoAll(
ImGuiTable* table);
3657 IMGUI_API
void TableRemove(
ImGuiTable* table);
3658 IMGUI_API
void TableGcCompactTransientBuffers(
ImGuiTable* table);
3660 IMGUI_API
void TableGcCompactSettings();
3663 IMGUI_API
void TableLoadSettings(
ImGuiTable* table);
3664 IMGUI_API
void TableSaveSettings(
ImGuiTable* table);
3665 IMGUI_API
void TableResetSettings(
ImGuiTable* table);
3667 IMGUI_API
void TableSettingsAddSettingsHandler();
3673 IMGUI_API
bool BeginTabBarEx(
ImGuiTabBar* tab_bar,
const ImRect& bb, ImGuiTabBarFlags flags);
3678 inline int TabBarGetTabOrder(
ImGuiTabBar* tab_bar,
ImGuiTabItem* tab) {
return tab_bar->Tabs.index_from_ptr(tab); }
3681 IMGUI_API
void TabBarRemoveTab(
ImGuiTabBar* tab_bar, ImGuiID tab_id);
3686 IMGUI_API
bool TabBarProcessReorder(
ImGuiTabBar* tab_bar);
3687 IMGUI_API
bool TabItemEx(
ImGuiTabBar* tab_bar,
const char* label,
bool* p_open, ImGuiTabItemFlags flags,
ImGuiWindow* docked_window);
3688 IMGUI_API
ImVec2 TabItemCalcSize(
const char* label,
bool has_close_button_or_unsaved_marker);
3690 IMGUI_API
void TabItemBackground(
ImDrawList* draw_list,
const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col);
3691 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);
3696 IMGUI_API
void RenderText(
ImVec2 pos,
const char* text,
const char* text_end = NULL,
bool hide_text_after_hash =
true);
3697 IMGUI_API
void RenderTextWrapped(
ImVec2 pos,
const char* text,
const char* text_end,
float wrap_width);
3698 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);
3699 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);
3700 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);
3701 IMGUI_API
void RenderFrame(
ImVec2 p_min,
ImVec2 p_max, ImU32 fill_col,
bool border =
true,
float rounding = 0.0f);
3702 IMGUI_API
void RenderFrameBorder(
ImVec2 p_min,
ImVec2 p_max,
float rounding = 0.0f);
3703 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);
3704 IMGUI_API
void RenderNavHighlight(
const ImRect& bb, ImGuiID
id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_None);
3705 IMGUI_API
const char* FindRenderedTextEnd(
const char* text,
const char* text_end = NULL);
3706 IMGUI_API
void RenderMouseCursor(
ImVec2 pos,
float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow);
3709 IMGUI_API
void RenderArrow(
ImDrawList* draw_list,
ImVec2 pos, ImU32 col, ImGuiDir dir,
float scale = 1.0f);
3711 IMGUI_API
void RenderCheckMark(
ImDrawList* draw_list,
ImVec2 pos, ImU32 col,
float sz);
3712 IMGUI_API
void RenderArrowPointingAt(
ImDrawList* draw_list,
ImVec2 pos,
ImVec2 half_sz, ImGuiDir direction, ImU32 col);
3713 IMGUI_API
void RenderArrowDockMenu(
ImDrawList* draw_list,
ImVec2 p_min,
float sz, ImU32 col);
3714 IMGUI_API
void RenderRectFilledRangeH(
ImDrawList* draw_list,
const ImRect& rect, ImU32 col,
float x_start_norm,
float x_end_norm,
float rounding);
3715 IMGUI_API
void RenderRectFilledWithHole(
ImDrawList* draw_list,
const ImRect& outer,
const ImRect& inner, ImU32 col,
float rounding);
3716 IMGUI_API ImDrawFlags CalcRoundingFlagsForRectInRect(
const ImRect& r_in,
const ImRect& r_outer,
float threshold);
3719 IMGUI_API
void TextEx(
const char* text,
const char* text_end = NULL, ImGuiTextFlags flags = 0);
3720 IMGUI_API
bool ButtonEx(
const char* label,
const ImVec2& size_arg =
ImVec2(0, 0), ImGuiButtonFlags flags = 0);
3721 IMGUI_API
bool ArrowButtonEx(
const char* str_id, ImGuiDir dir,
ImVec2 size_arg, ImGuiButtonFlags flags = 0);
3722 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);
3723 IMGUI_API
void SeparatorEx(ImGuiSeparatorFlags flags,
float thickness = 1.0f);
3724 IMGUI_API
void SeparatorTextEx(ImGuiID
id,
const char* label,
const char* label_end,
float extra_width);
3725 IMGUI_API
bool CheckboxFlags(
const char* label, ImS64* flags, ImS64 flags_value);
3726 IMGUI_API
bool CheckboxFlags(
const char* label, ImU64* flags, ImU64 flags_value);
3729 IMGUI_API
bool CloseButton(ImGuiID
id,
const ImVec2& pos);
3731 IMGUI_API
void Scrollbar(ImGuiAxis axis);
3732 IMGUI_API
bool ScrollbarEx(
const ImRect& bb, ImGuiID
id, ImGuiAxis axis, ImS64* p_scroll_v, ImS64 avail_v, ImS64 contents_v, ImDrawFlags flags);
3734 IMGUI_API ImGuiID GetWindowScrollbarID(
ImGuiWindow* window, ImGuiAxis axis);
3735 IMGUI_API ImGuiID GetWindowResizeCornerID(
ImGuiWindow* window,
int n);
3736 IMGUI_API ImGuiID GetWindowResizeBorderID(
ImGuiWindow* window, ImGuiDir dir);
3739 IMGUI_API
bool ButtonBehavior(
const ImRect& bb, ImGuiID
id,
bool* out_hovered,
bool* out_held, ImGuiButtonFlags flags = 0);
3740 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);
3741 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);
3742 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);
3743 IMGUI_API
bool TreeNodeBehavior(ImGuiID
id, ImGuiTreeNodeFlags flags,
const char* label,
const char* label_end = NULL);
3744 IMGUI_API
void TreePushOverrideID(ImGuiID
id);
3745 IMGUI_API
void TreeNodeSetOpen(ImGuiID
id,
bool open);
3746 IMGUI_API
bool TreeNodeUpdateNextOpen(ImGuiID
id, ImGuiTreeNodeFlags flags);
3747 IMGUI_API
void SetNextItemSelectionUserData(ImGuiSelectionUserData selection_user_data);
3752 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);
3753 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);
3754 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);
3755 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);
3756 template<
typename T> IMGUI_API T RoundScalarWithFormatT(
const char* format, ImGuiDataType data_type, T v);
3757 template<
typename T> IMGUI_API
bool CheckboxFlagsT(
const char* label, T* flags, T flags_value);
3761 IMGUI_API
int DataTypeFormatString(
char* buf,
int buf_size, ImGuiDataType data_type,
const void* p_data,
const char* format);
3762 IMGUI_API
void DataTypeApplyOp(ImGuiDataType data_type,
int op,
void* output,
const void* arg_1,
const void* arg_2);
3763 IMGUI_API
bool DataTypeApplyFromText(
const char* buf, ImGuiDataType data_type,
void* p_data,
const char* format);
3764 IMGUI_API
int DataTypeCompare(ImGuiDataType data_type,
const void* arg_1,
const void* arg_2);
3765 IMGUI_API
bool DataTypeClamp(ImGuiDataType data_type,
void* p_data,
const void* p_min,
const void* p_max);
3768 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);
3769 IMGUI_API
void InputTextDeactivateHook(ImGuiID
id);
3770 IMGUI_API
bool TempInputText(
const ImRect& bb, ImGuiID
id,
const char* label,
char* buf,
int buf_size, ImGuiInputTextFlags flags);
3771 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);
3772 inline bool TempInputIsActive(ImGuiID
id) {
ImGuiContext& g = *GImGui;
return (g.ActiveId ==
id && g.TempInputId ==
id); }
3773 inline ImGuiInputTextState* GetInputTextState(ImGuiID
id) {
ImGuiContext& g = *GImGui;
return (
id != 0 && g.InputTextState.ID ==
id) ? &g.InputTextState : NULL; }
3776 IMGUI_API
void ColorTooltip(
const char* text,
const float* col, ImGuiColorEditFlags flags);
3777 IMGUI_API
void ColorEditOptionsPopup(
const float* col, ImGuiColorEditFlags flags);
3778 IMGUI_API
void ColorPickerOptionsPopup(
const float* ref_col, ImGuiColorEditFlags flags);
3781 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);
3784 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);
3785 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);
3786 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);
3789 IMGUI_API
void GcCompactTransientMiscBuffers();
3790 IMGUI_API
void GcCompactTransientWindowBuffers(
ImGuiWindow* window);
3791 IMGUI_API
void GcAwakeTransientWindowBuffers(
ImGuiWindow* window);
3794 IMGUI_API
void DebugLog(
const char* fmt, ...) IM_FMTARGS(1);
3795 IMGUI_API
void DebugLogV(
const char* fmt, va_list args) IM_FMTLIST(1);
3796 IMGUI_API
void DebugAllocHook(
ImGuiDebugAllocInfo* info,
int frame_count,
void* ptr,
size_t size);
3799 IMGUI_API
void ErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback,
void* user_data = NULL);
3800 IMGUI_API
void ErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback,
void* user_data = NULL);
3801 IMGUI_API
void ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
3802 IMGUI_API
void DebugDrawCursorPos(ImU32 col = IM_COL32(255, 0, 0, 255));
3803 IMGUI_API
void DebugDrawLineExtents(ImU32 col = IM_COL32(255, 0, 0, 255));
3804 IMGUI_API
void DebugDrawItemRect(ImU32 col = IM_COL32(255, 0, 0, 255));
3805 IMGUI_API
void DebugLocateItem(ImGuiID target_id);
3806 IMGUI_API
void DebugLocateItemOnHover(ImGuiID target_id);
3807 IMGUI_API
void DebugLocateItemResolveWithLastItem();
3808 IMGUI_API
void DebugBreakClearData();
3809 IMGUI_API
bool DebugBreakButton(
const char* label,
const char* description_of_location);
3810 IMGUI_API
void DebugBreakButtonTooltip(
bool keyboard_only,
const char* description_of_location);
3812 IMGUI_API
void DebugHookIdInfo(ImGuiID
id, ImGuiDataType data_type,
const void* data_id,
const void* data_id_end);
3814 IMGUI_API
void DebugNodeDockNode(
ImGuiDockNode* node,
const char* label);
3816 IMGUI_API
void DebugNodeDrawCmdShowMeshAndBoundingBox(
ImDrawList* out_draw_list,
const ImDrawList* draw_list,
const ImDrawCmd* draw_cmd,
bool show_mesh,
bool show_aabb);
3817 IMGUI_API
void DebugNodeFont(
ImFont* font);
3819 IMGUI_API
void DebugNodeStorage(
ImGuiStorage* storage,
const char* label);
3820 IMGUI_API
void DebugNodeTabBar(
ImGuiTabBar* tab_bar,
const char* label);
3821 IMGUI_API
void DebugNodeTable(
ImGuiTable* table);
3825 IMGUI_API
void DebugNodeWindow(
ImGuiWindow* window,
const char* label);
3828 IMGUI_API
void DebugNodeWindowsListByBeginStackParent(
ImGuiWindow** windows,
int windows_size,
ImGuiWindow* parent_in_begin_stack);
3830 IMGUI_API
void DebugRenderKeyboardPreview(
ImDrawList* draw_list);
3834 #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS 3835 inline void SetItemUsingMouseWheel() { SetItemKeyOwner(ImGuiKey_MouseWheelY); }
3836 inline bool TreeNodeBehaviorIsOpen(ImGuiID
id, ImGuiTreeNodeFlags flags = 0) {
return TreeNodeUpdateNextOpen(
id, flags); }
3845 #ifndef IMGUI_DISABLE_OBSOLETE_KEYIO 3846 inline bool IsKeyPressedMap(ImGuiKey key,
bool repeat =
true) { IM_ASSERT(IsNamedKey(key));
return IsKeyPressed(key, repeat); }
3863 #ifdef IMGUI_ENABLE_STB_TRUETYPE 3864 IMGUI_API
const ImFontBuilderIO* ImFontAtlasGetBuilderForStbTruetype();
3866 IMGUI_API
void ImFontAtlasUpdateConfigDataPointers(
ImFontAtlas* atlas);
3867 IMGUI_API
void ImFontAtlasBuildInit(
ImFontAtlas* atlas);
3869 IMGUI_API
void ImFontAtlasBuildPackCustomRects(
ImFontAtlas* atlas,
void* stbrp_context_opaque);
3870 IMGUI_API
void ImFontAtlasBuildFinish(
ImFontAtlas* atlas);
3871 IMGUI_API
void ImFontAtlasBuildRender8bppRectFromString(
ImFontAtlas* atlas,
int x,
int y,
int w,
int h,
const char* in_str,
char in_marker_char,
unsigned char in_marker_pixel_value);
3872 IMGUI_API
void ImFontAtlasBuildRender32bppRectFromString(
ImFontAtlas* atlas,
int x,
int y,
int w,
int h,
const char* in_str,
char in_marker_char,
unsigned int in_marker_pixel_value);
3873 IMGUI_API
void ImFontAtlasBuildMultiplyCalcLookupTable(
unsigned char out_table[256],
float in_multiply_factor);
3874 IMGUI_API
void ImFontAtlasBuildMultiplyRectAlpha8(
const unsigned char table[256],
unsigned char* pixels,
int x,
int y,
int w,
int h,
int stride);
3880 #ifdef IMGUI_ENABLE_TEST_ENGINE 3882 extern void ImGuiTestEngineHook_ItemInfo(
ImGuiContext* ctx, ImGuiID
id,
const char* label, ImGuiItemStatusFlags flags);
3883 extern void ImGuiTestEngineHook_Log(
ImGuiContext* ctx,
const char* fmt, ...);
3884 extern const char* ImGuiTestEngine_FindItemDebugLabel(
ImGuiContext* ctx, ImGuiID
id);
3887 #define IMGUI_TEST_ENGINE_ITEM_ADD(_ID,_BB,_ITEM_DATA) if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemAdd(&g, _ID, _BB, _ITEM_DATA) // Register item bounding box 3888 #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) 3889 #define IMGUI_TEST_ENGINE_LOG(_FMT,...) if (g.TestEngineHookItems) ImGuiTestEngineHook_Log(&g, _FMT, __VA_ARGS__) // Custom log entry from user land into test log 3891 #define IMGUI_TEST_ENGINE_ITEM_ADD(_BB,_ID) ((void)0) 3892 #define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS) ((void)g) 3897 #if defined(__clang__) 3898 #pragma clang diagnostic pop 3899 #elif defined(__GNUC__) 3900 #pragma GCC diagnostic pop 3904 #pragma warning (pop) 3907 #endif // #ifndef IMGUI_DISABLE Definition: imgui_internal.h:1219
Definition: imgui_internal.h:2903
Definition: imgui_internal.h:782
Definition: imgui_internal.h:1403
Definition: imgui_internal.h:1692
Definition: imgui_internal.h:1237
Definition: imgui_internal.h:1936
Definition: imgui_internal.h:1654
Definition: imgui_internal.h:720
Definition: imgui_internal.h:1643
Definition: imgui_internal.h:2022
Definition: imgui_internal.h:739
Definition: imgui_internal.h:1074
Definition: imgui_internal.h:1624
Definition: imgui_internal.h:523
Definition: imgui_internal.h:1015
Definition: imgui_internal.h:2883
Definition: imgui_internal.h:1084
Definition: imgui_internal.h:1868
Definition: imgui_internal.h:1262
Definition: imgui_internal.h:604
Definition: imgui_internal.h:2029
Definition: imgui_internal.h:208
Definition: imgui_internal.h:2057
Definition: imgui_internal.h:1269
Definition: imgui_internal.h:1025
Definition: imgui_internal.h:1276
Definition: imgui_internal.h:619
Definition: imgui_internal.h:3172
Definition: imgui_internal.h:1890
Definition: imgui_internal.h:1161
Graphics::Surface * scale(const Graphics::Surface &srcImage, int xSize, int ySize)
Definition: imgui_internal.h:3048
MouseButton
Definition: events.h:183
Definition: imgui_internal.h:1038
Definition: imgui_internal.h:633
Definition: imgui_internal.h:2039
Definition: imgui_internal.h:1460
Definition: imgui_internal.h:1056
Definition: imgui_internal.h:1434
Definition: imgui_internal.h:1448
Definition: imgui_internal.h:2714
Definition: imgui_internal.h:1008
Definition: imgui_internal.h:1530
Definition: imgui_internal.h:1873
Definition: imgui_internal.h:2957
Definition: imgui_internal.h:3857
Definition: imgui_internal.h:1702
Definition: imgui_internal.h:1202
Definition: imgui_internal.h:531
Definition: imgui_internal.h:1244
Definition: imgui_internal.h:3016
Definition: imgui_internal.h:1608
Definition: imgui_internal.h:1789
Definition: imgui_internal.h:3219
Definition: imgui_internal.h:2664
Definition: imgui_internal.h:663
Definition: imgui_internal.h:1297
Definition: imgui_internal.h:2103
Definition: imgui_internal.h:1303
Definition: imgui_internal.h:3035
Definition: imgui_internal.h:805
Definition: imgui_internal.h:1289
Definition: imgui_internal.h:1991
Definition: imgui_internal.h:3195
Definition: imgui_internal.h:2088
Definition: imgui_internal.h:686
Definition: imgui_internal.h:541
Definition: imgui_internal.h:1955
Definition: imgui_internal.h:322
Definition: imgui_internal.h:1517